summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--GTIWebServerTestAggActionHandlerUnit.pas268
-rw-r--r--epost.lpr159
-rw-r--r--epost.lps214
-rw-r--r--epostunit.pas4650
-rw-r--r--typenunit.pas1124
-rw-r--r--werteunit.pas1650
6 files changed, 4186 insertions, 3879 deletions
diff --git a/GTIWebServerTestAggActionHandlerUnit.pas b/GTIWebServerTestAggActionHandlerUnit.pas
index c49259b..b96e218 100644
--- a/GTIWebServerTestAggActionHandlerUnit.pas
+++ b/GTIWebServerTestAggActionHandlerUnit.pas
@@ -1,134 +1,134 @@
-unit GTIWebServerTestAggActionHandlerUnit;
-
-interface
-
-uses
- sysutils,
- zstream,
- ftfont,
- agg_2D,
- FPimage,
- FPImgCanv,
- FPWritePNG,
- FPWriteJPEG,
- agg_basics;
-
-type
-
- { TTestAggActionHandler }
-
- TTestAggActionHandler = class
- public
- const ImageWidth = 800;
- const ImageHeight = 480;
- const RGBA_Width = 4;
- const LineCount = 30;
- const FontFilePath = '/usr/share/fonts/TTF/DejaVuSans.ttf';
- procedure HandlePlug;
- procedure DrawStuff(agg: Agg2D_ptr);
- procedure DrawText(aImage: TFPMemoryImage);
- end;
-
-implementation
-
-{ TTestAggActionHandler }
-
-procedure TTestAggActionHandler.HandlePlug;
-var
- agg: Agg2D_ptr;
- buf: array of int8;
- image: TFPMemoryImage;
- writer: TFPWriterJPEG;
- x, y: Integer;
- c: TFPColor;
- function getBufItemAsWord(aDelta: byte): Word;
- var
- actualY: Integer;
- begin
- actualY := ImageHeight - y - 1;
- result :=
- Word(buf[x * RGBA_Width + actualY * ImageWidth * RGBA_Width + aDelta] shl 8)
- or Word(128);
- end;
-begin
- SetLength(buf, ImageWidth * ImageHeight * RGBA_Width);
- New(agg, Construct);
- agg^.attach(@(buf[0]), ImageWidth, ImageHeight, ImageWidth * RGBA_Width);
- DrawStuff(agg);
- Dispose(agg, Destruct); // not necessary to keep it after rendering is finished
- image := TFPMemoryImage.create(ImageWidth, ImageHeight);
- for x := 0 to ImageWidth - 1 do
- for y := 0 to ImageHeight - 1 do
- begin
- c.red := getBufItemAsWord(2);
- c.green := getBufItemAsWord(1);
- c.blue := getBufItemAsWord(0);
- c.alpha := getBufItemAsWord(3);
- image.Colors[x, y] := c;
- end;
- {
- writer := TFPWriterPNG.create;
- writer.CompressionLevel := clmax;
- writer.WordSized := False; // reduce size
- }
- writer := TFPWriterJPEG.Create;
- writer.CompressionQuality := $FF div 3; // bad quality plz
- writer.ProgressiveEncoding := True;
- image.SaveToFile('wut.jpeg', writer);
- image.Free;
- writer.Free;
-end;
-
-procedure TTestAggActionHandler.DrawStuff(agg: Agg2D_ptr);
-var
- i: Integer;
- x, y, px, py, d: Double;
-begin
- agg^.clearAll(0, 0, 0);
- agg^.lineColor(0, 0, 0, 255);
- agg^.lineWidth(3);
- agg^.rectangle(0, 0, ImageWidth, ImageHeight);
- agg^.font(FontFilePath, 16);
- d := ImageWidth / LineCount;
- agg^.lineColor(0, 0, 0, 100);
- for i := 1 to LineCount - 1 do
- begin
- x := i * d;
- agg^.line(x, 0, x, ImageHeight );
- end;
- for i := 1 to trunc(ImageHeight / d) - 1 do
- begin
- y := i * d;
- agg^.line(0, y, ImageWidth, y);
- end;
- x := 0;
- y := ImageHeight / 2;
- px := x;
- py := y;
- agg^.lineColor(255, 0, 0, 200);
- agg^.fillColor(0, 0, 0, 200);
- for i := 0 to LineCount - 1 do
- begin
- x := x + d;
- y := y + Random(Round(ImageHeight / 3)) - ImageHeight / 6;
- if y < 0 then
- y := ImageHeight / 6;
- if y >= ImageHeight then
- y := ImageHeight - ImageHeight / 6;
- agg^.line(px, py, x, y);
- agg^.text(x, y, char_ptr(IntToStr(i) + ' bla'));
- px := x;
- py := y;
- end;
-end;
-
-procedure TTestAggActionHandler.DrawText(aImage: TFPMemoryImage);
-var
- canvas: TFPImageCanvas;
- font: TFreeTypeFont;
-begin
- font := TFreeTypeFont.create;
- canvas := TFPImageCanvas.create(aImage);
-end;
-
-end. \ No newline at end of file
+unit GTIWebServerTestAggActionHandlerUnit;
+
+interface
+
+uses
+ sysutils,
+ zstream,
+ ftfont,
+ agg_2D,
+ FPimage,
+ FPImgCanv,
+ FPWritePNG,
+ FPWriteJPEG,
+ agg_basics;
+
+type
+
+ { TTestAggActionHandler }
+
+ TTestAggActionHandler = class
+ public
+ const ImageWidth = 800;
+ const ImageHeight = 480;
+ const RGBA_Width = 4;
+ const LineCount = 30;
+ const FontFilePath = '/usr/share/fonts/TTF/DejaVuSans.ttf';
+ procedure HandlePlug;
+ procedure DrawStuff(agg: agg2D_ptr);
+ procedure DrawText(aImage: TFPMemoryImage);
+ end;
+
+implementation
+
+{ TTestAggActionHandler }
+
+procedure TTestAggActionHandler.HandlePlug;
+var
+ agg: agg2D_ptr;
+ buf: array of int8;
+ image: TFPMemoryImage;
+ writer: TFPWriterJPEG;
+ x, y: integer;
+ c: TFPColor;
+ function getBufItemAsWord(aDelta: byte): word;
+ var
+ actualY: integer;
+ begin
+ actualY := ImageHeight - y - 1;
+ result :=
+ word(buf[x * RGBA_Width + actualY * ImageWidth * RGBA_Width + aDelta] shl 8)
+ or word(128);
+ end;
+begin
+ setLength(buf, ImageWidth * ImageHeight * RGBA_Width);
+ New(agg, Construct);
+ agg^.attach(@(buf[0]), ImageWidth, ImageHeight, ImageWidth * RGBA_Width);
+ DrawStuff(agg);
+ Dispose(agg, Destruct); // not necessary to keep it after rendering is finished
+ image := TFPMemoryImage.create(ImageWidth, ImageHeight);
+ for x := 0 to ImageWidth - 1 do
+ for y := 0 to ImageHeight - 1 do
+ begin
+ c.red := getBufItemAsWord(2);
+ c.green := getBufItemAsWord(1);
+ c.blue := getBufItemAsWord(0);
+ c.alpha := getBufItemAsWord(3);
+ image.Colors[x, y] := c;
+ end;
+ {
+ writer := TFPWriterPNG.create;
+ writer.CompressionLevel := clmax;
+ writer.WordSized := false; // reduce size
+ }
+ writer := TFPWriterJPEG.create;
+ writer.CompressionQuality := $FF div 3; // bad quality plz
+ writer.ProgressiveEncoding := true;
+ image.SaveToFile('wut.jpeg', writer);
+ image.free;
+ writer.free;
+end;
+
+procedure TTestAggActionHandler.DrawStuff(agg: agg2D_ptr);
+var
+ i: integer;
+ x, y, px, py, d: double;
+begin
+ agg^.clearAll(0, 0, 0);
+ agg^.lineColor(0, 0, 0, 255);
+ agg^.lineWidth(3);
+ agg^.rectangle(0, 0, ImageWidth, ImageHeight);
+ agg^.font(FontFilePath, 16);
+ d := ImageWidth / LineCount;
+ agg^.lineColor(0, 0, 0, 100);
+ for i := 1 to LineCount - 1 do
+ begin
+ x := i * d;
+ agg^.line(x, 0, x, ImageHeight );
+ end;
+ for i := 1 to trunc(ImageHeight / d) - 1 do
+ begin
+ y := i * d;
+ agg^.line(0, y, ImageWidth, y);
+ end;
+ x := 0;
+ y := ImageHeight / 2;
+ px := x;
+ py := y;
+ agg^.lineColor(255, 0, 0, 200);
+ agg^.fillColor(0, 0, 0, 200);
+ for i := 0 to LineCount - 1 do
+ begin
+ x := x + d;
+ y := y + Random(round(ImageHeight / 3)) - ImageHeight / 6;
+ if y < 0 then
+ y := ImageHeight / 6;
+ if y >= ImageHeight then
+ y := ImageHeight - ImageHeight / 6;
+ agg^.line(px, py, x, y);
+ agg^.text(x, y, char_ptr(intToStr(i) + ' bla'));
+ px := x;
+ py := y;
+ end;
+end;
+
+procedure TTestAggActionHandler.DrawText(aImage: TFPMemoryImage);
+var
+ canvas: TFPImageCanvas;
+ font: TFreeTypeFont;
+begin
+ font := TFreeTypeFont.create;
+ canvas := TFPImageCanvas.create(aImage);
+end;
+
+end.
diff --git a/epost.lpr b/epost.lpr
index aabe01a..79eb06f 100644
--- a/epost.lpr
+++ b/epost.lpr
@@ -8,37 +8,37 @@ uses
{$IFDEF UNIX}{$IFDEF UseCThreads}
cthreads,
{$ENDIF}{$ENDIF}
- Classes,
+ classes,
{ you can add units after this }
sysutils, epostunit, mystringlistunit, lowlevelunit;
var
- maxthreads,i,j,k: longint;
- inf,bekannteBefehle: tMyStringlist;
+ maxThreads,i,j,k: longint;
+ inf,bekannteBefehle: tMyStringList;
s: string;
b,syntaxtest,parallelLesen: boolean;
wertes: tWerteArray;
- Konturen: tKonturenArray;
+ konturen: tKonturenArray;
Warnstufe: tWarnstufe;
-procedure werte_aufraeumen;
+procedure werteAufraeumen;
var
i: integer;
begin
for i:=0 to length(wertes)-1 do
if assigned(wertes[i]) then
wertes[i].free;
- setlength(wertes,0);
- for i:=0 to length(Konturen)-1 do
- if assigned(Konturen[i]) then
- Konturen[i].free;
- setlength(Konturen,0);
+ setLength(wertes,0);
+ for i:=0 to length(konturen)-1 do
+ if assigned(konturen[i]) then
+ konturen[i].free;
+ setLength(konturen,0);
end;
procedure aufraeumen;
begin
- warte_auf_externeBefehle;
- werte_aufraeumen;
+ warteAufExterneBefehle;
+ werteAufraeumen;
inf.free;
end;
@@ -51,13 +51,13 @@ begin
gibAus('oder: '+paramstr(0)+' input.epost -L',3);
halt(1);
end;
- maxthreads:=1;
+ maxThreads:=1;
Warnstufe:=wsStreng;
parallelLesen:=false;
- setlength(wertes,0);
- setlength(Konturen,0);
+ setLength(wertes,0);
+ setLength(konturen,0);
behalteLogs:=(paramcount=2) and (paramstr(2)='-L');
- inf:=tMyStringlist.create(nil,'');
+ inf:=tMyStringList.create(nil,'');
inf.nichtInSubRoutine('^lösche Werte '); // Zeilen, die hierauf passen, werden nicht an subRoutinen-Aufrufe
inf.nichtInSubRoutine('^lösche Kontur '); // von metaReadln gegeben, sondern nach hinten ans Hauptprogramm verschoben
inf.loadFromFile(paramstr(1));
@@ -121,18 +121,18 @@ begin
end;
if istDasBefehl('warte auf externe Befehle',s,bekannteBefehle,false) then begin
if not syntaxtest then begin
- warte_auf_externeBefehle;
+ warteAufExterneBefehle;
for i:=0 to length(wertes)-1 do
wertes[i].warteAufBeendigungDesLeseThreads;
end;
continue;
end;
if istDasBefehl('exprtofloat-Test:',s,bekannteBefehle,true) then begin
- gibAus('exprtofloat-Test: '+s+'='+floattostr(wertes[length(wertes)-1].exprtofloat(syntaxtest,s)),3);
+ gibAus('exprtofloat-Test: '+s+'='+floatToStr(wertes[length(wertes)-1].exprToFloat(syntaxtest,s)),3);
continue;
end;
if istDasBefehl('dupliziere',s,bekannteBefehle,true) then begin
- i:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
+ i:=findeWerte(erstesArgument(s),nil,@wertes,@konturen,false);
if i<0 then begin
aufraeumen;
halt(1);
@@ -142,7 +142,7 @@ begin
aufraeumen;
halt(1);
end;
- j:=findeWerte(s,inf,@wertes,@Konturen,true);
+ j:=findeWerte(s,inf,@wertes,@konturen,true);
if j<0 then begin
aufraeumen;
halt(1);
@@ -151,19 +151,19 @@ begin
continue;
end;
if istDasBefehl('erzeuge Dummy-Werte',s,bekannteBefehle,true) then begin
- i:=findeWerte(s,inf,@wertes,@Konturen,true);
+ i:=findeWerte(s,inf,@wertes,@konturen,true);
if i<0 then begin
aufraeumen;
halt(1);
end;
wertes[i].free;
- wertes[i]:=tWerte.create(@Konturen,@wertes);
+ wertes[i]:=tWerte.create(@konturen,@wertes);
wertes[i].bezeichner:=s;
continue;
end;
if istDasBefehl('Daten einlesen',s,bekannteBefehle,true) then begin
b:=not startetMit('(ohne Ausgaben)',s);
- i:=findeWerte(s,inf,@wertes,@Konturen,true);
+ i:=findeWerte(s,inf,@wertes,@konturen,true);
if i<0 then begin
aufraeumen;
halt(1);
@@ -175,25 +175,25 @@ begin
halt(1);
end;
if istDasBefehl('Ascii laden',s,bekannteBefehle,true) then begin
- i:=findeWerte(erstesArgument(s),inf,@wertes,@Konturen,true);
+ i:=findeWerte(erstesArgument(s),inf,@wertes,@konturen,true);
if wertes[i].ladeAscii(syntaxtest,s) then
continue;
aufraeumen;
halt(1);
end;
if istDasBefehl('Linearkombination',s,bekannteBefehle,true) then begin
- i:=findeWerte(s,inf,@wertes,@Konturen,true);
+ i:=findeWerte(s,inf,@wertes,@konturen,true);
if i<0 then begin
aufraeumen;
halt(1);
end;
- if wertes[i].berechneLiKo(syntaxtest,inf,maxthreads) then
+ if wertes[i].berechneLiKo(syntaxtest,inf,maxThreads) then
continue;
aufraeumen;
halt(1);
end;
if istDasBefehl('Agglomeration',s,bekannteBefehle,true) then begin
- i:=findeWerte(s,inf,@wertes,@Konturen,true);
+ i:=findeWerte(s,inf,@wertes,@konturen,true);
if i<0 then begin
aufraeumen;
halt(1);
@@ -204,7 +204,7 @@ begin
halt(1);
end;
if istDasBefehl('teile',s,bekannteBefehle,true) then begin
- i:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
+ i:=findeWerte(erstesArgument(s),nil,@wertes,@konturen,false);
if i<0 then begin
aufraeumen;
halt(1);
@@ -214,7 +214,7 @@ begin
aufraeumen;
halt(1);
end;
- j:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
+ j:=findeWerte(erstesArgument(s),nil,@wertes,@konturen,false);
if j<0 then begin
aufraeumen;
halt(1);
@@ -224,18 +224,18 @@ begin
aufraeumen;
halt(1);
end;
- k:=findeWerte(s,inf,@wertes,@Konturen,true);
+ k:=findeWerte(s,inf,@wertes,@konturen,true);
if k<0 then begin
aufraeumen;
halt(1);
end;
- if wertes[k].berechneQuotient(syntaxtest,inf,maxthreads,i,j) then
+ if wertes[k].berechneQuotient(syntaxtest,inf,maxThreads,i,j) then
continue;
aufraeumen;
halt(1);
end;
if istDasBefehl('multipliziere',s,bekannteBefehle,true) then begin
- i:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
+ i:=findeWerte(erstesArgument(s),nil,@wertes,@konturen,false);
if i<0 then begin
aufraeumen;
halt(1);
@@ -245,7 +245,7 @@ begin
aufraeumen;
halt(1);
end;
- j:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
+ j:=findeWerte(erstesArgument(s),nil,@wertes,@konturen,false);
if j<0 then begin
aufraeumen;
halt(1);
@@ -255,51 +255,51 @@ begin
aufraeumen;
halt(1);
end;
- k:=findeWerte(s,inf,@wertes,@Konturen,true);
+ k:=findeWerte(s,inf,@wertes,@konturen,true);
if k<0 then begin
aufraeumen;
halt(1);
end;
- if wertes[k].berechneProdukt(syntaxtest,inf,maxthreads,i,j) then
+ if wertes[k].berechneProdukt(syntaxtest,inf,maxThreads,i,j) then
continue;
aufraeumen;
halt(1);
end;
if istDasBefehl('FFT2d',s,bekannteBefehle,true) then begin
- i:=findeWerte(s,inf,@wertes,@Konturen,true);
+ i:=findeWerte(s,inf,@wertes,@konturen,true);
if i<0 then begin
aufraeumen;
halt(1);
end;
- if wertes[i].berechneFFT2d(syntaxtest,inf,maxthreads,Warnstufe) then
+ if wertes[i].berechneFFT2d(syntaxtest,inf,maxThreads,Warnstufe) then
continue;
aufraeumen;
halt(1);
end;
if istDasBefehl('FFT',s,bekannteBefehle,true) then begin
- i:=findeWerte(s,inf,@wertes,@Konturen,false);
+ i:=findeWerte(s,inf,@wertes,@konturen,false);
if i<0 then begin
aufraeumen;
halt(1);
end;
- if wertes[i].berechneFFT(syntaxtest,inf,maxthreads,Warnstufe) then
+ if wertes[i].berechneFFT(syntaxtest,inf,maxThreads,Warnstufe) then
continue;
aufraeumen;
halt(1);
end;
if istDasBefehl('fitte Gauße an',s,bekannteBefehle,true) then begin
- i:=findeWerte(s,nil,@wertes,@Konturen,false);
+ i:=findeWerte(s,nil,@wertes,@konturen,false);
if i<0 then begin
aufraeumen;
halt(1);
end;
- if wertes[i].fitteGausze(syntaxtest,inf,maxthreads) then
+ if wertes[i].fitteGausze(syntaxtest,inf,maxThreads) then
continue;
aufraeumen;
halt(1);
end;
if istDasBefehl('Zeitfrequenzanalyse',s,bekannteBefehle,true) then begin
- j:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
+ j:=findeWerte(erstesArgument(s),nil,@wertes,@konturen,false);
if j<0 then begin
aufraeumen;
halt(1);
@@ -309,18 +309,18 @@ begin
aufraeumen;
halt(1);
end;
- i:=findeWerte(s,inf,@wertes,@Konturen,true);
+ i:=findeWerte(s,inf,@wertes,@konturen,true);
if i<0 then begin
aufraeumen;
halt(1);
end;
- if wertes[i].berechneZeitfrequenzanalyse(syntaxtest,inf,maxthreads,wertes[j],Warnstufe) then
+ if wertes[i].berechneZeitfrequenzanalyse(syntaxtest,inf,maxThreads,wertes[j],Warnstufe) then
continue;
aufraeumen;
halt(1);
end;
if istDasBefehl('Verzerrung',s,bekannteBefehle,true) then begin
- j:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
+ j:=findeWerte(erstesArgument(s),nil,@wertes,@konturen,false);
if j<0 then begin
aufraeumen;
halt(1);
@@ -330,18 +330,18 @@ begin
aufraeumen;
halt(1);
end;
- i:=findeWerte(s,inf,@wertes,@Konturen,true);
+ i:=findeWerte(s,inf,@wertes,@konturen,true);
if i<0 then begin
aufraeumen;
halt(1);
end;
- if wertes[i].berechneVerzerrung(syntaxtest,inf,maxthreads,wertes[j],Warnstufe) then
+ if wertes[i].berechneVerzerrung(syntaxtest,inf,maxThreads,wertes[j],Warnstufe) then
continue;
aufraeumen;
halt(1);
end;
if istDasBefehl('lambda',s,bekannteBefehle,true) then begin
- j:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
+ j:=findeWerte(erstesArgument(s),nil,@wertes,@konturen,false);
if j<0 then begin
aufraeumen;
halt(1);
@@ -351,40 +351,51 @@ begin
aufraeumen;
halt(1);
end;
- i:=findeWerte(s,inf,@wertes,@Konturen,true);
+ i:=findeWerte(s,inf,@wertes,@konturen,true);
if i<0 then begin
aufraeumen;
halt(1);
end;
- if wertes[i].berechneLambdaZuOmegaVerzerrung(syntaxtest,inf,maxthreads,wertes[j]) then
+ if wertes[i].berechneLambdaZuOmegaVerzerrung(syntaxtest,inf,maxThreads,wertes[j]) then
continue;
aufraeumen;
halt(1);
end;
if istDasBefehl('entferne Artefakte in',s,bekannteBefehle,true) then begin
- i:=findeWerte(s,nil,@wertes,@Konturen,false);
+ i:=findeWerte(s,nil,@wertes,@konturen,false);
if i<0 then begin
aufraeumen;
halt(1);
end;
- if wertes[i].entferneArtefakte(syntaxtest,inf,maxthreads) then
+ if wertes[i].entferneArtefakte(syntaxtest,inf,maxThreads) then
continue;
aufraeumen;
halt(1);
end;
if istDasBefehl('extrahiere Einhüllende von',s,bekannteBefehle,true) then begin
- i:=findeWerte(s,nil,@wertes,@Konturen,false);
+ i:=findeWerte(s,nil,@wertes,@konturen,false);
if i<0 then begin
aufraeumen;
halt(1);
end;
- if wertes[i].extrahiereEinhuellende(syntaxtest,inf,maxthreads,Warnstufe) then
+ if wertes[i].extrahiereEinhuellende(syntaxtest,inf,maxThreads,Warnstufe) then
+ continue;
+ aufraeumen;
+ halt(1);
+ end;
+ if istDasBefehl('extrahiere Phase von',s,bekannteBefehle,true) then begin
+ i:=findeWerte(s,nil,@wertes,@konturen,false);
+ if i<0 then begin
+ aufraeumen;
+ halt(1);
+ end;
+ if wertes[i].extrahierePhase(syntaxtest,inf,maxThreads,Warnstufe) then
continue;
aufraeumen;
halt(1);
end;
if istDasBefehl('integriere',s,bekannteBefehle,true) then begin
- j:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
+ j:=findeWerte(erstesArgument(s),nil,@wertes,@konturen,false);
if j<0 then begin
aufraeumen;
halt(1);
@@ -394,18 +405,18 @@ begin
aufraeumen;
halt(1);
end;
- i:=findeWerte(s,inf,@wertes,@Konturen,true);
+ i:=findeWerte(s,inf,@wertes,@konturen,true);
if i<0 then begin
aufraeumen;
halt(1);
end;
- if wertes[i].berechneIntegral(syntaxtest,inf,maxthreads,wertes[j]) then
+ if wertes[i].berechneIntegral(syntaxtest,inf,maxThreads,wertes[j]) then
continue;
aufraeumen;
halt(1);
end;
if istDasBefehl('korreliere',s,bekannteBefehle,true) then begin
- j:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
+ j:=findeWerte(erstesArgument(s),nil,@wertes,@konturen,false);
if j<0 then begin
aufraeumen;
halt(1);
@@ -415,12 +426,12 @@ begin
aufraeumen;
halt(1);
end;
- i:=findeWerte(s,inf,@wertes,@Konturen,true);
+ i:=findeWerte(s,inf,@wertes,@konturen,true);
if i<0 then begin
aufraeumen;
halt(1);
end;
- if wertes[i].berechneKorrelation(syntaxtest,inf,maxthreads,wertes[j]) then
+ if wertes[i].berechneKorrelation(syntaxtest,inf,maxThreads,wertes[j]) then
continue;
aufraeumen;
halt(1);
@@ -431,7 +442,7 @@ begin
end;
if istDasBefehl('maximale und minimale Dichten bestimmen',s,bekannteBefehle,true) then begin
b:=startetMit('(symmetrisch) ',s);
- i:=findeWerte(s,nil,@wertes,@Konturen,false);
+ i:=findeWerte(s,nil,@wertes,@konturen,false);
if i<0 then begin
aufraeumen;
halt(1);
@@ -441,7 +452,7 @@ begin
end;
if istDasBefehl('maximale und minimale Dichten angleichen',s,bekannteBefehle,true) then begin
b:=startetMit('(symmetrisch) ',s);
- i:=findeWerte(s,nil,@wertes,@Konturen,false);
+ i:=findeWerte(s,nil,@wertes,@konturen,false);
if i<0 then begin
aufraeumen;
halt(1);
@@ -450,19 +461,19 @@ begin
continue;
end;
if istDasBefehl('lineares Bild',s,bekannteBefehle,true) then begin
- i:=findeWerte(s,nil,@wertes,@Konturen,false);
+ i:=findeWerte(s,nil,@wertes,@konturen,false);
if i<0 then begin
aufraeumen;
halt(1);
end;
- if not wertes[i].erzeugeLinearesBild(syntaxtest,inf,maxthreads) then begin
+ if not wertes[i].erzeugeLinearesBild(syntaxtest,inf,maxThreads) then begin
aufraeumen;
halt(1);
end;
continue;
end;
if istDasBefehl('Ascii',s,bekannteBefehle,true) then begin
- i:=findeWerte(s,nil,@wertes,@Konturen,false);
+ i:=findeWerte(s,nil,@wertes,@konturen,false);
if i<0 then begin
aufraeumen;
halt(1);
@@ -474,7 +485,7 @@ begin
continue;
end;
if istDasBefehl('Lineout',s,bekannteBefehle,true) then begin
- i:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
+ i:=findeWerte(erstesArgument(s),nil,@wertes,@konturen,false);
if (i<0) or not wertes[i].erzeugeLineout(syntaxtest,s) then begin
aufraeumen;
halt(1);
@@ -482,7 +493,7 @@ begin
continue;
end;
if istDasBefehl('Binning',s,bekannteBefehle,true) then begin
- i:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
+ i:=findeWerte(erstesArgument(s),nil,@wertes,@konturen,false);
if (i<0) or not wertes[i].erzeugeBinning(syntaxtest,s) then begin
aufraeumen;
halt(1);
@@ -491,7 +502,7 @@ begin
end;
if istDasBefehl('lösche Werte',s,bekannteBefehle,true) then begin
while s<>'' do begin
- j:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
+ j:=findeWerte(erstesArgument(s),nil,@wertes,@konturen,false);
if j<0 then begin
aufraeumen;
halt(1);
@@ -499,13 +510,13 @@ begin
wertes[j].free;
for i:=j+1 to length(wertes)-1 do
wertes[i-1]:=wertes[i];
- setlength(wertes,length(wertes)-1);
+ setLength(wertes,length(wertes)-1);
end;
continue;
end;
if istDasBefehl('lösche Kontur',s,bekannteBefehle,true) then begin
while s<>'' do begin
- j:=findeKontur(erstesArgument(s),nil,@Wertes,@Konturen,false);
+ j:=findeKontur(erstesArgument(s),nil,@wertes,@konturen,false);
if j<0 then begin
aufraeumen;
halt(1);
@@ -513,7 +524,7 @@ begin
konturen[j].free;
for i:=j+1 to length(konturen)-1 do
konturen[i-1]:=konturen[i];
- setlength(konturen,length(konturen)-1);
+ setLength(konturen,length(konturen)-1);
end;
continue;
end;
@@ -523,8 +534,8 @@ begin
halt(1);
end;
if istDasBefehl('Kontur',s,bekannteBefehle,true) then begin
- i:=findeKontur(s,inf,@Wertes,@Konturen,true);
- if (i>=0) and Konturen[i].Init(syntaxtest,inf,@wertes,maxthreads) then continue;
+ i:=findeKontur(s,inf,@wertes,@konturen,true);
+ if (i>=0) and konturen[i].init(syntaxtest,inf,@wertes,maxThreads) then continue;
aufraeumen;
halt(1);
end;
@@ -535,7 +546,7 @@ begin
aufraeumen;
halt(1);
until false;
- werte_aufraeumen;
+ werteAufraeumen;
end;
aufraeumen;
if not behalteLogs then cleanupLogs;
diff --git a/epost.lps b/epost.lps
index a147152..3d3e628 100644
--- a/epost.lps
+++ b/epost.lps
@@ -3,13 +3,12 @@
<ProjectSession>
<Version Value="10"/>
<BuildModes Active="Default"/>
- <Units Count="24">
+ <Units Count="26">
<Unit0>
<Filename Value="epost.lpr"/>
<IsPartOfProject Value="True"/>
- <TopLine Value="206"/>
- <CursorPos X="35" Y="134"/>
- <FoldState Value=" T0iWg4A123111221]6515]6[A431313[A821[Y4121[85]i5"/>
+ <TopLine Value="41"/>
+ <CursorPos X="86" Y="131"/>
<UsageCount Value="202"/>
<Loaded Value="True"/>
</Unit0>
@@ -23,11 +22,9 @@
<Unit2>
<Filename Value="epostunit.pas"/>
<IsPartOfProject Value="True"/>
- <IsVisibleTab Value="True"/>
<EditorIndex Value="1"/>
- <TopLine Value="3832"/>
- <CursorPos X="54" Y="3846"/>
- <FoldState Value=" T0\Zm$0C191g"/>
+ <TopLine Value="7019"/>
+ <CursorPos X="92" Y="7031"/>
<UsageCount Value="201"/>
<Loaded Value="True"/>
</Unit2>
@@ -41,43 +38,45 @@
<Unit4>
<Filename Value="werteunit.pas"/>
<IsPartOfProject Value="True"/>
- <EditorIndex Value="4"/>
- <TopLine Value="1855"/>
- <CursorPos X="87" Y="1872"/>
- <FoldState Value=" T0wEkl051X111B"/>
+ <EditorIndex Value="6"/>
+ <TopLine Value="634"/>
+ <CursorPos X="16" Y="652"/>
<UsageCount Value="200"/>
<Loaded Value="True"/>
</Unit4>
<Unit5>
<Filename Value="typenunit.pas"/>
<IsPartOfProject Value="True"/>
- <EditorIndex Value="6"/>
- <TopLine Value="1855"/>
- <CursorPos Y="1872"/>
+ <EditorIndex Value="8"/>
+ <TopLine Value="1271"/>
+ <CursorPos X="35" Y="1284"/>
<UsageCount Value="200"/>
<Loaded Value="True"/>
</Unit5>
<Unit6>
<Filename Value="../units/fftunit.pas"/>
<IsPartOfProject Value="True"/>
- <EditorIndex Value="-1"/>
- <CursorPos X="3" Y="15"/>
- <UsageCount Value="159"/>
+ <EditorIndex Value="2"/>
+ <TopLine Value="55"/>
+ <CursorPos X="126" Y="71"/>
+ <UsageCount Value="174"/>
+ <Loaded Value="True"/>
</Unit6>
<Unit7>
<Filename Value="../units/fftunit.inc"/>
<IsPartOfProject Value="True"/>
- <EditorIndex Value="-1"/>
- <TopLine Value="10"/>
- <CursorPos X="22" Y="10"/>
- <UsageCount Value="156"/>
+ <EditorIndex Value="3"/>
+ <TopLine Value="133"/>
+ <CursorPos X="99" Y="152"/>
+ <UsageCount Value="171"/>
+ <Loaded Value="True"/>
</Unit7>
<Unit8>
<Filename Value="gauszFit.inc"/>
<IsPartOfProject Value="True"/>
- <EditorIndex Value="5"/>
+ <EditorIndex Value="7"/>
<CursorPos X="35" Y="10"/>
- <UsageCount Value="62"/>
+ <UsageCount Value="77"/>
<Loaded Value="True"/>
</Unit8>
<Unit9>
@@ -85,34 +84,35 @@
<EditorIndex Value="-1"/>
<TopLine Value="1612"/>
<CursorPos X="2" Y="1675"/>
- <UsageCount Value="10"/>
+ <UsageCount Value="8"/>
</Unit9>
<Unit10>
<Filename Value="../units/mystringlistunit.pas"/>
<EditorIndex Value="-1"/>
<TopLine Value="638"/>
<CursorPos X="58" Y="660"/>
- <UsageCount Value="12"/>
+ <UsageCount Value="10"/>
</Unit10>
<Unit11>
<Filename Value="../units/lowlevelunit.pas"/>
- <EditorIndex Value="3"/>
- <TopLine Value="61"/>
- <CursorPos Y="79"/>
- <UsageCount Value="60"/>
+ <IsVisibleTab Value="True"/>
+ <EditorIndex Value="5"/>
+ <TopLine Value="380"/>
+ <CursorPos X="70" Y="403"/>
+ <UsageCount Value="68"/>
<Loaded Value="True"/>
</Unit11>
<Unit12>
<Filename Value="../units/randomunit.pas"/>
<EditorIndex Value="-1"/>
- <UsageCount Value="10"/>
+ <UsageCount Value="8"/>
</Unit12>
<Unit13>
<Filename Value="../units/matheunit.pas"/>
- <EditorIndex Value="2"/>
+ <EditorIndex Value="4"/>
<TopLine Value="517"/>
<CursorPos X="21" Y="393"/>
- <UsageCount Value="34"/>
+ <UsageCount Value="42"/>
<Loaded Value="True"/>
</Unit13>
<Unit14>
@@ -120,48 +120,48 @@
<EditorIndex Value="-1"/>
<TopLine Value="186"/>
<CursorPos Y="161"/>
- <UsageCount Value="12"/>
+ <UsageCount Value="10"/>
</Unit14>
<Unit15>
<Filename Value="/usr/lib/fpc/src/rtl/inc/objpash.inc"/>
<EditorIndex Value="-1"/>
<TopLine Value="182"/>
<CursorPos X="21" Y="202"/>
- <UsageCount Value="3"/>
+ <UsageCount Value="1"/>
</Unit15>
<Unit16>
<Filename Value="/usr/lib/fpc/src/rtl/unix/bunxovlh.inc"/>
<EditorIndex Value="-1"/>
<TopLine Value="61"/>
<CursorPos X="10" Y="99"/>
- <UsageCount Value="1"/>
+ <UsageCount Value="9"/>
</Unit16>
<Unit17>
<Filename Value="/usr/lib/fpc/src/rtl/unix/baseunix.pp"/>
<UnitName Value="BaseUnix"/>
<EditorIndex Value="-1"/>
<TopLine Value="61"/>
- <UsageCount Value="1"/>
+ <UsageCount Value="9"/>
</Unit17>
<Unit18>
<Filename Value="/usr/lib/fpc/src/rtl/unix/bunxovl.inc"/>
<EditorIndex Value="-1"/>
<TopLine Value="414"/>
<CursorPos X="20" Y="434"/>
- <UsageCount Value="1"/>
+ <UsageCount Value="9"/>
</Unit18>
<Unit19>
<Filename Value="/usr/lib/fpc/src/rtl/linux/bunxsysc.inc"/>
<EditorIndex Value="-1"/>
<TopLine Value="16"/>
- <UsageCount Value="1"/>
+ <UsageCount Value="9"/>
</Unit19>
<Unit20>
<Filename Value="/usr/lib/fpc/src/rtl/unix/bunxh.inc"/>
<EditorIndex Value="-1"/>
<TopLine Value="74"/>
<CursorPos X="15" Y="102"/>
- <UsageCount Value="1"/>
+ <UsageCount Value="9"/>
</Unit20>
<Unit21>
<Filename Value="/usr/lib/fpc/src/packages/fcl-image/src/fpimage.pp"/>
@@ -169,142 +169,156 @@
<EditorIndex Value="-1"/>
<TopLine Value="10"/>
<CursorPos X="3" Y="30"/>
- <UsageCount Value="1"/>
+ <UsageCount Value="9"/>
</Unit21>
<Unit22>
<Filename Value="../fpGUI/src/corelib/render/software/agg_basics.pas"/>
<EditorIndex Value="-1"/>
<TopLine Value="327"/>
<CursorPos X="12" Y="347"/>
- <UsageCount Value="4"/>
+ <UsageCount Value="2"/>
</Unit22>
<Unit23>
<Filename Value="/usr/lib/fpc/src/rtl/objpas/classes/classesh.inc"/>
<EditorIndex Value="-1"/>
<TopLine Value="673"/>
<CursorPos X="42" Y="705"/>
- <UsageCount Value="4"/>
+ <UsageCount Value="2"/>
</Unit23>
+ <Unit24>
+ <Filename Value="/usr/lib/fpc/src/rtl/objpas/math.pp"/>
+ <EditorIndex Value="-1"/>
+ <TopLine Value="166"/>
+ <CursorPos X="10" Y="183"/>
+ <UsageCount Value="10"/>
+ </Unit24>
+ <Unit25>
+ <Filename Value="GTIWebServerTestAggActionHandlerUnit.pas"/>
+ <EditorIndex Value="-1"/>
+ <TopLine Value="53"/>
+ <CursorPos X="49" Y="82"/>
+ <UsageCount Value="10"/>
+ </Unit25>
</Units>
<JumpHistory Count="30" HistoryIndex="29">
<Position1>
- <Filename Value="epostunit.pas"/>
- <Caret Line="4038" Column="58" TopLine="4022"/>
+ <Filename Value="werteunit.pas"/>
+ <Caret Line="374" Column="18" TopLine="345"/>
</Position1>
<Position2>
- <Filename Value="epostunit.pas"/>
- <Caret Line="3524" Column="68" TopLine="3504"/>
+ <Filename Value="werteunit.pas"/>
+ <Caret Line="379" Column="17" TopLine="350"/>
</Position2>
<Position3>
- <Filename Value="epostunit.pas"/>
- <Caret Line="3624" Column="53" TopLine="3602"/>
+ <Filename Value="werteunit.pas"/>
+ <Caret Line="382" Column="12" TopLine="353"/>
</Position3>
<Position4>
- <Filename Value="epostunit.pas"/>
- <Caret Line="3453" Column="67" TopLine="3437"/>
+ <Filename Value="werteunit.pas"/>
+ <Caret Line="393" Column="12" TopLine="364"/>
</Position4>
<Position5>
- <Filename Value="epostunit.pas"/>
- <Caret Line="3719" Column="28" TopLine="3703"/>
+ <Filename Value="werteunit.pas"/>
+ <Caret Line="399" Column="31" TopLine="370"/>
</Position5>
<Position6>
- <Filename Value="epostunit.pas"/>
+ <Filename Value="werteunit.pas"/>
+ <Caret Line="405" Column="16" TopLine="376"/>
</Position6>
<Position7>
- <Filename Value="epostunit.pas"/>
- <Caret Line="923" Column="27" TopLine="895"/>
+ <Filename Value="werteunit.pas"/>
+ <Caret Line="406" Column="18" TopLine="377"/>
</Position7>
<Position8>
- <Filename Value="epostunit.pas"/>
- <Caret Line="2018" Column="27" TopLine="1993"/>
+ <Filename Value="werteunit.pas"/>
+ <Caret Line="411" Column="17" TopLine="382"/>
</Position8>
<Position9>
- <Filename Value="epostunit.pas"/>
- <Caret Line="2082" Column="27" TopLine="2146"/>
+ <Filename Value="werteunit.pas"/>
+ <Caret Line="414" Column="12" TopLine="385"/>
</Position9>
<Position10>
- <Filename Value="epostunit.pas"/>
- <Caret Line="2236" Column="27" TopLine="2249"/>
+ <Filename Value="werteunit.pas"/>
+ <Caret Line="425" Column="12" TopLine="396"/>
</Position10>
<Position11>
- <Filename Value="epostunit.pas"/>
- <Caret Line="2405" Column="27" TopLine="2376"/>
+ <Filename Value="werteunit.pas"/>
+ <Caret Line="431" Column="31" TopLine="402"/>
</Position11>
<Position12>
- <Filename Value="epostunit.pas"/>
- <Caret Line="2506" TopLine="2475"/>
+ <Filename Value="werteunit.pas"/>
+ <Caret Line="437" Column="16" TopLine="408"/>
</Position12>
<Position13>
- <Filename Value="epostunit.pas"/>
- <Caret Line="2600" Column="40" TopLine="2598"/>
+ <Filename Value="werteunit.pas"/>
+ <Caret Line="438" Column="18" TopLine="409"/>
</Position13>
<Position14>
- <Filename Value="epostunit.pas"/>
- <Caret Line="2616" Column="55" TopLine="2599"/>
+ <Filename Value="werteunit.pas"/>
+ <Caret Line="443" Column="17" TopLine="414"/>
</Position14>
<Position15>
- <Filename Value="epostunit.pas"/>
- <Caret Line="2617" Column="101" TopLine="2603"/>
+ <Filename Value="werteunit.pas"/>
+ <Caret Line="446" Column="12" TopLine="417"/>
</Position15>
<Position16>
- <Filename Value="epostunit.pas"/>
- <Caret Line="4097" Column="77" TopLine="4075"/>
+ <Filename Value="werteunit.pas"/>
+ <Caret Line="497" Column="12" TopLine="469"/>
</Position16>
<Position17>
- <Filename Value="typenunit.pas"/>
- <Caret Line="2482" Column="28" TopLine="2489"/>
+ <Filename Value="werteunit.pas"/>
+ <Caret Line="500" Column="16" TopLine="472"/>
</Position17>
<Position18>
- <Filename Value="typenunit.pas"/>
- <Caret Line="2635" Column="41" TopLine="2616"/>
+ <Filename Value="werteunit.pas"/>
+ <Caret Line="501" Column="18" TopLine="473"/>
</Position18>
<Position19>
- <Filename Value="typenunit.pas"/>
- <Caret Line="1673" Column="9" TopLine="1655"/>
+ <Filename Value="werteunit.pas"/>
+ <Caret Line="502" Column="28" TopLine="474"/>
</Position19>
<Position20>
- <Filename Value="typenunit.pas"/>
- <Caret Line="2635" TopLine="2617"/>
+ <Filename Value="werteunit.pas"/>
+ <Caret Line="504" Column="14" TopLine="476"/>
</Position20>
<Position21>
- <Filename Value="typenunit.pas"/>
- <Caret Line="2636" Column="15" TopLine="2617"/>
+ <Filename Value="werteunit.pas"/>
+ <Caret Line="505" Column="16" TopLine="477"/>
</Position21>
<Position22>
- <Filename Value="typenunit.pas"/>
- <Caret Line="2658" Column="35" TopLine="2630"/>
+ <Filename Value="werteunit.pas"/>
+ <Caret Line="557" Column="12" TopLine="529"/>
</Position22>
<Position23>
- <Filename Value="typenunit.pas"/>
- <Caret Line="2659" Column="9" TopLine="2631"/>
+ <Filename Value="werteunit.pas"/>
+ <Caret Line="1078" Column="74" TopLine="1050"/>
</Position23>
<Position24>
- <Filename Value="typenunit.pas"/>
- <Caret Line="2667" Column="35" TopLine="2639"/>
+ <Filename Value="werteunit.pas"/>
</Position24>
<Position25>
- <Filename Value="typenunit.pas"/>
- <Caret Line="2668" Column="9" TopLine="2640"/>
+ <Filename Value="epostunit.pas"/>
+ <Caret Line="5678" Column="108" TopLine="5666"/>
</Position25>
<Position26>
- <Filename Value="typenunit.pas"/>
- <Caret Line="2677" Column="9" TopLine="2649"/>
+ <Filename Value="werteunit.pas"/>
+ <Caret Line="1026" Column="67" TopLine="1020"/>
</Position26>
<Position27>
<Filename Value="typenunit.pas"/>
- <Caret Line="2638" Column="83" TopLine="2620"/>
+ <Caret Line="2475" Column="86" TopLine="2463"/>
</Position27>
<Position28>
- <Filename Value="werteunit.pas"/>
- <Caret Line="53" TopLine="53"/>
+ <Filename Value="../units/lowlevelunit.pas"/>
+ <Caret Line="41" Column="44" TopLine="24"/>
</Position28>
<Position29>
<Filename Value="epostunit.pas"/>
- <Caret Line="2680" TopLine="2663"/>
+ <Caret Line="9" Column="62"/>
</Position29>
<Position30>
- <Filename Value="epostunit.pas"/>
- <Caret Line="3773" TopLine="3746"/>
+ <Filename Value="../units/lowlevelunit.pas"/>
+ <Caret Line="388" Column="58" TopLine="380"/>
</Position30>
</JumpHistory>
</ProjectSession>
diff --git a/epostunit.pas b/epostunit.pas
index bec70d4..5c62226 100644
--- a/epostunit.pas
+++ b/epostunit.pas
@@ -5,10 +5,10 @@ unit epostunit;
interface
uses
- Classes, SysUtils, mystringlistunit, werteunit, typenunit, process, lowlevelunit, matheunit, fftunit;
+ classes, sysutils, mystringlistunit, werteunit, typenunit, process, lowlevelunit, matheunit, fftunit;
type
- TBmpHeader = packed record
+ tBmpHeader = packed record
bfType1 : byte;
bfType2 : byte;
bfSize : longint;
@@ -48,9 +48,9 @@ type
tDatenVorfahr = class(tObject)
bezeichner: string;
- Konturen: pTKonturenArray;
+ konturen: pTKonturenArray;
wertes: pTWerteArray;
- constructor create(Kont: pTKonturenArray; wert: pTWerteArray);
+ constructor create(kont: pTKonturenArray; wert: pTWerteArray);
function callBackGetValue(s: string): extended;
end;
@@ -60,20 +60,20 @@ type
function rxmax: extended;
function rtmin: extended;
function rtmax: extended;
- function sortiere_nach_y(mt: longint): boolean; overload;
- function sortiere_nach_y(mt,von,bis: longint): boolean; overload;
- function exprtofloat(st: boolean; s: string; kvs: tKnownValues): extended;
+ function sortiereNachY(mT: longint): boolean; overload;
+ function sortiereNachY(mT,von,bis: longint): boolean; overload;
+ function exprToFloat(sT: boolean; s: string; kvs: tKnownValues): extended;
public
orte: tExtPointArray;
- 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;
- property xmin: extended read rxmin;
- property xmax: extended read rxmax;
- property tmin: extended read rtmin;
- property tmax: extended read rtmax;
- constructor create(Kont: pTKonturenArray; wert: pTWerteArray);
+ 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;
+ property xMin: extended read rxmin;
+ property xMax: extended read rxmax;
+ property tMin: extended read rtmin;
+ property tMax: extended read rtmax;
+ constructor create(kont: pTKonturenArray; wert: pTWerteArray);
destructor destroy; override;
end;
tLeseThread = class;
@@ -85,34 +85,34 @@ type
private
leseThread: tLeseThread;
function findeAlleDateien(nam: string; var dat: tGenerischeInputDateiInfoArray; Vorlage: tGenerischeInputDateiInfo): boolean;
- function ermittleExterneInputParameter(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);
+ 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;
procedure wTransformationen(tr: tTransformation);
- function rXsteps: longint;
- procedure wXsteps(xs: longint);
- function rTsiz: longint;
- procedure wTsiz(ts: longint);
- function rXstart: extended;
- procedure wXstart(xs: extended);
- function rXstop: extended;
- procedure wXstop(xs: extended);
- function rTstart: extended;
- procedure wTstart(ts: extended);
- function rTstop: extended;
- procedure wTstop(ts: extended);
+ function rXSteps: longint;
+ procedure wXSteps(xS: longint);
+ function rTSiz: longint;
+ procedure wTSiz(tS: longint);
+ function rXStart: extended;
+ procedure wXStart(xS: extended);
+ function rXStop: extended;
+ procedure wXStop(xS: extended);
+ function rTStart: extended;
+ procedure wTStart(tS: extended);
+ function rTStop: extended;
+ procedure wTStop(tS: extended);
function rNp: extended;
procedure wNp(np: extended);
function rBeta: extended;
procedure wBeta(beta: extended);
- function rMinw: extended;
- procedure wMinw(miw: extended);
- function rMaxw: extended;
- procedure wMaxw(maw: extended);
- function xscale: extended;
- function tscale: extended;
- function dichtenParameterErkannt(st: boolean; s: string; var bekannteBefehle: tMyStringList; threads,xmin,xmax,tmin,tmax: longint): boolean;
+ function rMinW: extended;
+ procedure wMinW(miW: extended);
+ function rMaxW: extended;
+ procedure wMaxW(maW: extended);
+ function xScale: extended;
+ function tScale: extended;
+ function dichtenParameterErkannt(sT: boolean; s: string; var bekannteBefehle: tMyStringList; threads,xMin,xMax,tMin,tMax: longint): boolean;
function kont2disk(senkrecht: boolean; x: extended): longint; overload; inline;
function kont2disk(dir: char; x: extended): longint; overload;
function kont2diskFak(senkrecht: boolean; x: extended): extended; overload; inline;
@@ -121,70 +121,72 @@ type
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);
+ procedure holeRAM(ausgaben: byte); inline;
public
eWerte: tLLWerteExtended;
dWerte: tLLWerteDouble;
sWerte: tLLWerteSingle;
- Genauigkeit: tGenauigkeit;
- constructor create(Kont: pTKonturenArray; wert: pTWerteArray); overload;
- constructor create(original: tWerte; xmin,xmax: longint); overload;
+ genauigkeit: tGenauigkeit;
+ constructor create(kont: pTKonturenArray; wert: pTWerteArray); overload;
+ constructor create(original: tWerte; xMin,xMax: longint); overload;
destructor destroy; override;
procedure warteAufBeendigungDesLeseThreads;
- procedure kopiereVon(st: boolean; original: tWerte); overload;
- procedure kopiereVon(st: boolean; original: tWerte; xmin,xmax: longint); overload;
- function ladeDateien(st: boolean; f: tMyStringlist; pl,sa: boolean): boolean;
- function ladeAscii(st: boolean; datei: string): boolean;
- function berechneLiKo(st: boolean; f: tMyStringlist; threads: longint): boolean;
- function berechneAgglomeration(st: boolean; var f: tMyStringlist): 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; f: tMyStringlist; symmetrisch: boolean);
+ procedure kopiereVon(sT: boolean; original: tWerte); overload;
+ procedure kopiereVon(sT: boolean; original: tWerte; xMin,xMax: longint); overload;
+ function ladeDateien(sT: boolean; f: tMyStringList; pl,sA: boolean): boolean;
+ function ladeAscii(sT: boolean; datei: string): boolean;
+ function berechneLiKo(sT: boolean; f: tMyStringList; threads: longint): boolean;
+ function berechneAgglomeration(sT: boolean; var f: tMyStringList): 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; f: tMyStringList; symmetrisch: boolean);
function fft(threads: longint; senkrecht,invers: boolean; const vor,nach: tFFTDatenordnung; fen: tFenster; hg: extended; out pvFehler: extended; Warn: tWarnstufe): boolean; overload;
- procedure initFuerGauszFit(st: boolean; daten: tWerte; senkrecht: boolean; adLaenge: longint; adStart,adStop: extended);
- function fitteGausze(st: boolean; f: tMyStringlist; threads: longint): boolean;
- 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 berechneLambdaZuOmegaVerzerrung(st: boolean; f: tMyStringList; threads: longint; quelle: tWerte): boolean;
- function entferneArtefakte(st: boolean; f: tMyStringlist; threads: longint): boolean;
- function extrahiereEinhuellende(st: boolean; f: tMyStringlist; threads: longint; 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; f: tMyStringlist): boolean;
- function erzeugeLineout(st: boolean; params: string): boolean;
- function erzeugeBinning(st: boolean; params: string): boolean;
+ procedure initFuerGauszFit(sT: boolean; daten: tWerte; senkrecht: boolean; adLaenge: longint; adStart,adStop: extended);
+ function fitteGausze(sT: boolean; f: tMyStringList; threads: longint): boolean;
+ 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 berechneLambdaZuOmegaVerzerrung(sT: boolean; f: tMyStringList; threads: longint; quelle: tWerte): boolean;
+ function entferneArtefakte(sT: boolean; f: tMyStringList; threads: longint): boolean;
+ function extrahiereEinhuellende(sT: boolean; f: tMyStringList; threads: longint; Warn: tWarnstufe): boolean;
+ function extrahierePhase(sT: boolean; f: tMyStringList; threads: longint; 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; f: tMyStringList): boolean;
+ function erzeugeLineout(sT: boolean; params: string): boolean;
+ function erzeugeBinning(sT: boolean; params: string): boolean;
procedure spiegle(threads: longint); overload;
- procedure spiegle(threads,tmin,tmax: longint); overload;
- procedure fft2dNachbearbeitung(threads: longint; nb: tFFTDatenordnung);
+ procedure spiegle(threads,tMin,tMax: longint); overload;
+ procedure fft2dNachbearbeitung(threads: longint; nB: tFFTDatenordnung);
procedure schreibeWert(var f: textfile; x,y: longint);
- function exprtofloat(st: boolean; s: string): extended;
- function paramsdump: string;
+ function exprToFloat(sT: boolean; s: string): extended;
+ function paramsDump: string;
procedure beendeLeseThreadWennFertig;
- property Transformationen: tTransformation read rTransformationen write wTransformationen;
- property _xsteps: longint read rXsteps write wXsteps;
- property _tsiz: longint read rTsiz write wTsiz;
-// property _xstart: extended read rXstart write wXstart;
-// property _xstop: extended read rXstop write wXstop;
-// property _tstart: extended read rTstart write wTstart;
-// property _tstop: extended read rTstop write wTstop;
+ property transformationen: tTransformation read rTransformationen write wTransformationen;
+ property _xSteps: longint read rXSteps write wXSteps;
+ property _tSiz: longint read rTSiz write wTSiz;
+// property _xStart: extended read rXStart write wXStart;
+// property _xStop: extended read rXStop write wXStop;
+// property _tStart: extended read rTStart write wTStart;
+// property _tStop: extended read rTStop write wTStop;
property _np: extended read rNp write wNp;
property _beta: extended read rBeta write wBeta;
- property _minw: extended read rMinw write wMinw;
- property _maxw: extended read rMaxw write wMaxw;
+ property _minW: extended read rMinW write wMinW;
+ property _maxW: extended read rMaxW write wMaxW;
end;
tAchse = record
- Lage: TLage;
- Striche: Longint;
- Faktor: extended;
+ lage: tLage;
+ striche: longint;
+ faktor: extended;
end;
- tBeschriftungsschritt = record
+ tBeschriftungsSchritt = record
bis,faktor: extended;
- schritte: longint;
- linear: boolean;
+ schritte: longint;
+ linear: boolean;
end;
tZuZeichnendeKontur = class
farbe: tRGB;
@@ -229,42 +231,42 @@ type
constructor create(faktor1, faktor2, produkt: tWerte; xMin,xMax,tMin,tMax,xOff,tOff: longint);
procedure stExecute; override;
end;
- tBilderthread = class(tLogThread)
- nummer,mt,breite,wbreite,hoehe,
- whoehe,gesbreite,lof,oof,rof,uof: longint;
+ tBilderThread = class(tLogThread)
+ nummer,mT,breite,wBreite,hoehe,
+ wHoehe,gesBreite,lOf,oOf,rOf,uOf: longint;
ws: tWerteArray;
- xmi,xma,tmi,tma,xpmi,xpma: Longint;
- xz,yz: extended;
+ xMi,xMa,tMi,tMa,xPMi,xPMa: longint;
+ xZ,yZ: extended;
nbs: tTransformationArray;
- farben: trgbArray;
+ farben: tRGBArray;
wertes: array of tExtendedArray;
anzahlens: array of tLongintArray;
pals: tRGBArrayArray;
rahmen: boolean;
beschr: pTBeschriftungen;
- constructor create(i,maxthreads,ibreite,ihoehe,lo,oo,ro,uo: longint; const wes: tWerteArray; xmin,xmax,tmin,tmax: Longint; xzoom,yzoom: extended; Nachbearbeitungen: tTransformationArray; paletten: pTPalettenArray; beschri: pTBeschriftungen; rm: boolean);
+ constructor create(i,maxThreads,iBreite,iHoehe,lO,oO,rO,uO: longint; const wes: tWerteArray; xMin,xMax,tMin,tMax: longint; xZoom,yZoom: extended; nachbearbeitungen: tTransformationArray; paletten: pTPalettenArray; beschri: pTBeschriftungen; rm: boolean);
destructor destroy; override;
procedure stExecute; override;
procedure initAnzahlensFuerKontur;
end;
tDichteThread = class(tLogThread)
maxDichte,minDichte: extended;
- xmin,xmax,tmin,tmax: longint;
+ xMin,xMax,tMin,tMax: longint;
w: tWerte;
- constructor create(xmi,xma,tmi,tma: longint; const werte: tWerte);
+ constructor create(xMi,xMa,tMi,tMa: longint; const werte: tWerte);
procedure stExecute; override;
end;
tSpiegelThread = class(tLogThread)
- tmin,tmax: longint;
+ tMin,tMax: longint;
pW: tWerte;
- constructor create(tmi,tma: longint; pWerte: tWerte);
+ constructor create(tMi,tMa: longint; pWerte: tWerte);
procedure stExecute; override;
end;
tFFT2dNBThread = class(tLogThread)
- xmin,xmax: longint;
+ xMin,xMax: longint;
pW: tWerte;
- nb: tFFTDatenordnung;
- constructor create(xmi,xma: longint; pWerte: tWerte; endordnung: tFFTDatenordnung);
+ nB: tFFTDatenordnung;
+ constructor create(xMi,xMa: longint; pWerte: tWerte; endordnung: tFFTDatenordnung);
procedure stExecute; override;
end;
tFFTThread = class(tLogThread)
@@ -300,29 +302,29 @@ type
tKonturAusWertenThread = class(tLogThread)
w: tWerte;
s: extended;
- xmi,xma,tmi,tma: longint;
+ xMi,xMa,tMi,tMa: longint;
punkte: tExtPointArray;
- constructor create(werte: tWerte; schwelle: extended; xmin, xmax, tmin, tmax: longint);
+ constructor create(werte: tWerte; schwelle: extended; xMin, xMax, tMin, tMax: longint);
destructor destroy; override;
procedure stExecute; override;
end;
tIntegralThread = class(tLogThread)
qu,zi: tWerte;
- xmi,xma,tmi,tma,xof,tof: longint;
+ xMi,xMa,tMi,tMa,xOf,tOf: longint;
rtg: tIntegrationsRichtung;
- constructor create(quelle, ziel: tWerte; xmin, xmax, tmin, tmax, xoff, toff: longint; richtung: tIntegrationsRichtung);
+ constructor create(quelle, ziel: tWerte; xMin, xMax, tMin, tMax, xOff, tOff: longint; richtung: tIntegrationsRichtung);
procedure stExecute; override;
end;
tSortiereNachYThread = class(tLogThread)
- Kont: tKontur;
- vo,bi,mt: longint;
- constructor create(K: tKontur; threads,von,bis: longint);
+ kont: tKontur;
+ vo,bi,mT: longint;
+ constructor create(k: tKontur; threads,von,bis: longint);
procedure stExecute; override;
end;
tBefehlThread = class(tLogThread)
bg: boolean;
p: tProcess;
- constructor create(st: boolean; cmd: string; out erzeugungsErfolg: boolean);
+ constructor create(sT: boolean; cmd: string; out erzeugungsErfolg: boolean);
destructor destroy; override;
procedure stExecute; override;
end;
@@ -335,26 +337,26 @@ type
end;
tVerzerrInitThread = class(tLogThread)
qu,zi: tWerte;
- ZPs: tIntPointArray;
- ZGs: tExtPointArray;
- ZAs: tExtendedArray;
- xMi,xMa,tMi,tMa,x0,t0,mt,va: longint; // bzgl. Ziel
+ zPs: tIntPointArray;
+ zGs: tExtPointArray;
+ zAs: tExtendedArray;
+ xMi,xMa,tMi,tMa,x0,t0,mT,vA: longint; // bzgl. Ziel
eps: extended;
verz: tTransformation;
Warnstufe: tWarnstufe;
- constructor create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax,x0Abs,t0Abs,threads: longint; epsilon: extended; verzerrung: tTransformation; verzerrAnz: longint; zielpositionen: tIntPointArray; zielgewichte: tExtPointArray; Warn: tWarnstufe);
+ constructor create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax,x0Abs,t0Abs,threads: longint; epsilon: extended; verzerrung: tTransformation; verzerrAnz: longint; zielPositionen: tIntPointArray; zielGewichte: tExtPointArray; Warn: tWarnstufe);
destructor destroy; override;
procedure stExecute; override;
end;
tVerzerrThread = class(tLogThread)
qu,zi: tWerte;
- ZPs: tIntPointArray;
- ZGs: tExtPointArray;
- ZAs: tExtendedArray;
+ zPs: tIntPointArray;
+ zGs: tExtPointArray;
+ zAs: tExtendedArray;
xMi,xMa,tMi,tMa: longint; // bzgl. Ziel
- vb,nb: tTransformation;
- va,na: longint;
- constructor create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax: longint; zielpositionen: tIntPointArray; zielgewichte: tExtPointArray; zielanzahlen: tExtendedArray; Vorbearbeitungen,Nachbearbeitungen: tTransformation; vorAnz,nachAnz: longint);
+ vB,nB: tTransformation;
+ vA,nA: longint;
+ constructor create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax: longint; zielPositionen: tIntPointArray; zielGewichte: tExtPointArray; zielAnzahlen: tExtendedArray; vorbearbeitungen,nachbearbeitungen: tTransformation; vorAnz,nachAnz: longint);
procedure stExecute; override;
end;
tVerzerrLOThread = class(tLogThread)
@@ -370,24 +372,23 @@ type
xFen,tFen: tFenster;
hg: extended;
xMi,xMa,tMi,tMa: longint;
- constructor create(werte: tWerte; xMin,xMax,tMin,tMax: longint; x_Fenster,t_Fenster: tFenster; hintergrund: extended);
+ constructor create(werte: tWerte; xMin,xMax,tMin,tMax: longint; fensterX,fensterT: tFenster; hintergrund: extended);
procedure stExecute; override;
end;
-function neuePalette(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; 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;
-function externerBefehl(st: boolean; s: string): boolean;
-procedure warte_auf_externeBefehle;
+function findePalette(out palette: pTPalette; name: string): boolean;
+function erzeugeLegende(sT: boolean; f: tMyStringList; datei: string; qu: tWerte; minDichte,maxDichte: extended; nB: tTransformation; pal: pTPalette): 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;
+function externerBefehl(sT: boolean; s: string): boolean;
+procedure warteAufExterneBefehle;
procedure beendeExterneBefehleWennFertig;
var
- Paletten: array of tPalette;
+ paletten: array of tPalette;
behalteLogs: boolean;
externeBefehle: array of tBefehlThread;
@@ -397,10 +398,10 @@ uses math, systemunit;
// tDatenVorfahr ***************************************************************
-constructor tDatenVorfahr.create(Kont: pTKonturenArray; wert: pTWerteArray);
+constructor tDatenVorfahr.create(kont: pTKonturenArray; wert: pTWerteArray);
begin
inherited create;
- Konturen:=Kont;
+ konturen:=kont;
wertes:=wert;
bezeichner:='';
end;
@@ -413,56 +414,56 @@ begin
if startetMit('Kontur[',s) or startetMit('Konturen[',s) then begin
if pos('].',s)=0 then
fehler('Syntaxfehler, '']'' fehlt!');
- i:=findeKontur(erstesArgument(s,'].'),nil,Wertes,Konturen,false);
+ i:=findeKontur(erstesArgument(s,'].'),nil,wertes,konturen,false);
if i<0 then
fehler('Finde Kontur nicht!');
- if s='xmin' then result:=Konturen^[i].xmin
- else if s='xmax' then result:=Konturen^[i].xmax
- else if s='tmin' then result:=Konturen^[i].tmin
- else if s='tmax' then result:=Konturen^[i].tmax
- else if s='Breite' then result:=Konturen^[i].xmax-Konturen^[i].xmin
- else if s='Hoehe' then result:=Konturen^[i].tmax-Konturen^[i].tmin
+ if s='xMin' then result:=konturen^[i].xMin
+ else if s='xMax' then result:=konturen^[i].xMax
+ else if s='tMin' then result:=konturen^[i].tMin
+ else if s='tMax' then result:=konturen^[i].tMax
+ else if s='Breite' then result:=konturen^[i].xMax-konturen^[i].xMin
+ else if s='Hoehe' then result:=konturen^[i].tMax-konturen^[i].tMin
else fehler('Kenne Bezeichner '''+s+''' nicht als Eigenschaft einer Kontur!'#10 +
'Ich kenne:'#10 +
- '''xmin'''#10 +
- '''xmax'''#10 +
- '''tmin'''#10 +
- '''tmax'''#10 +
+ '''xMin'''#10 +
+ '''xMax'''#10 +
+ '''tMin'''#10 +
+ '''tMax'''#10 +
'''Breite'''#10 +
'''Hoehe'''
);
exit;
end;
- if startetMit('Wert[',s) or startetMit('Werte[',s) or startetMit('Wertes[',s) then begin
+ if startetMit('Wert[',s) or startetMit('Werte[',s) or startetMit('wertes[',s) then begin
if pos('].',s)=0 then
fehler('Syntaxfehler, '']'' fehlt!');
- i:=findeWerte(erstesArgument(s,'].'),nil,wertes,Konturen,false);
+ i:=findeWerte(erstesArgument(s,'].'),nil,wertes,konturen,false);
if i<0 then
fehler('Finde Werte nicht!');
- if (s='xmin') or (s='xstart') then result:=wertes^[i].Transformationen.xstart
- else if (s='xmax') or (s='xstop') then result:=wertes^[i].Transformationen.xstop
- else if (s='tmin') or (s='tstart') then result:=wertes^[i].Transformationen.tstart
- else if (s='tmax') or (s='tstop') then result:=wertes^[i].Transformationen.tstop
- else if (s='wmin') or (s='minw') then result:=wertes^[i]._minw
- else if (s='wmax') or (s='maxw') then result:=wertes^[i]._maxw
+ if (s='xMin') or (s='xStart') then result:=wertes^[i].transformationen.xStart
+ else if (s='xMax') or (s='xStop') then result:=wertes^[i].transformationen.xStop
+ else if (s='tMin') or (s='tStart') then result:=wertes^[i].transformationen.tStart
+ else if (s='tMax') or (s='tStop') then result:=wertes^[i].transformationen.tStop
+ else if (s='wMin') or (s='minW') then result:=wertes^[i]._minW
+ else if (s='wMax') or (s='maxW') then result:=wertes^[i]._maxW
else if s='np' then result:=wertes^[i]._np
else if (s='beta') or (s='β') then result:=wertes^[i]._beta
- else if s='Breite' then result:=wertes^[i].Transformationen.xstart-wertes^[i].Transformationen.xstop
- else if s='Hoehe' then result:=wertes^[i].Transformationen.tstart-wertes^[i].Transformationen.tstop
+ else if s='Breite' then result:=wertes^[i].transformationen.xStart-wertes^[i].transformationen.xStop
+ else if s='Hoehe' then result:=wertes^[i].transformationen.tStart-wertes^[i].transformationen.tStop
else fehler('Kenne Bezeichner '''+s+''' nicht als Eigenschaft von Werten!'#10 +
'Ich kenne:'#10 +
- '''xmin'''#10 +
- '''xstart'''#10 +
- '''xmax'''#10 +
- '''xstop'''#10 +
- '''tmin'''#10 +
- '''tstart'''#10 +
- '''tmax'''#10 +
- '''tstop'''#10 +
- '''wmin'''#10 +
- '''minw'''#10 +
- '''wmax'''#10 +
- '''maxw'''#10 +
+ '''xMin'''#10 +
+ '''xStart'''#10 +
+ '''xMax'''#10 +
+ '''xStop'''#10 +
+ '''tMin'''#10 +
+ '''tStart'''#10 +
+ '''tMax'''#10 +
+ '''tStop'''#10 +
+ '''wMin'''#10 +
+ '''minW'''#10 +
+ '''wMax'''#10 +
+ '''maxW'''#10 +
'''np'''#10 +
'''beta'''#10 +
'''β'''#10 +
@@ -476,48 +477,48 @@ end;
// tWerte **********************************************************************
-constructor tWerte.create(Kont: pTKonturenArray; wert: pTWerteArray);
+constructor tWerte.create(kont: pTKonturenArray; wert: pTWerteArray);
var
- ps: tExtrainfos;
+ ps: tExtraInfos;
begin
- inherited create(Kont,wert);
- ps:=tExtrainfos.create;
- Genauigkeit:=gSingle;
+ inherited create(kont,wert);
+ ps:=tExtraInfos.create;
+ genauigkeit:=gSingle;
leseThread:=nil;
sWerte:=tLLWerteSingle.create(ps);
dWerte:=tLLWerteDouble.create(ps);
eWerte:=tLLWerteExtended.create(ps);
end;
-constructor tWerte.create(original: tWerte; xmin,xmax: longint);
+constructor tWerte.create(original: tWerte; xMin,xMax: longint);
var
- ps: tExtrainfos;
+ ps: tExtraInfos;
begin
- inherited create(original.Konturen,original.wertes);
+ inherited create(original.konturen,original.wertes);
original.warteAufBeendigungDesLeseThreads;
- ps:=tExtrainfos.create;
+ ps:=tExtraInfos.create;
leseThread:=nil;
- Genauigkeit:=original.Genauigkeit;
- case Genauigkeit of
+ genauigkeit:=original.genauigkeit;
+ case genauigkeit of
gSingle: begin
- sWerte:=tLLWerteSingle.create(pTLLWerteSingle(@original.sWerte),ps,xmin,xmax);
+ sWerte:=tLLWerteSingle.create(pTLLWerteSingle(@original.sWerte),ps,xMin,xMax);
dWerte:=tLLWerteDouble.create(ps);
eWerte:=tLLWerteExtended.create(ps);
end;
gDouble: begin
sWerte:=tLLWerteSingle.create(ps);
- dWerte:=tLLWerteDouble.create(pTLLWerteDouble(@original.dWerte),ps,xmin,xmax);
+ dWerte:=tLLWerteDouble.create(pTLLWerteDouble(@original.dWerte),ps,xMin,xMax);
eWerte:=tLLWerteExtended.create(ps);
end;
gExtended: begin
sWerte:=tLLWerteSingle.create(ps);
dWerte:=tLLWerteDouble.create(ps);
- eWerte:=tLLWerteExtended.create(pTLLWerteExtended(@original.eWerte),ps,xmin,xmax);
+ eWerte:=tLLWerteExtended.create(pTLLWerteExtended(@original.eWerte),ps,xMin,xMax);
end;
end{of case};
if original.bezeichner='' then bezeichner:=''
else bezeichner:=original.bezeichner+'''';
- Transformationen:=original.Transformationen;
+ transformationen:=original.transformationen;
end;
destructor tWerte.destroy;
@@ -550,20 +551,20 @@ begin
end;
end;
-procedure tWerte.kopiereVon(st: boolean; original: tWerte); overload;
+procedure tWerte.kopiereVon(sT: boolean; original: tWerte); overload;
begin
- kopiereVon(st,original,0,original._xsteps-1);
+ kopiereVon(sT,original,0,original._xSteps-1);
end;
-procedure tWerte.kopiereVon(st: boolean; original: tWerte; xmin,xmax: longint); overload;
+procedure tWerte.kopiereVon(sT: boolean; original: tWerte; xMin,xMax: longint); overload;
begin
original.warteAufBeendigungDesLeseThreads;
- Transformationen:=tIdentitaet.create(original.Transformationen);
- Genauigkeit:=original.Genauigkeit;
- case Genauigkeit of
- gSingle: sWerte.kopiereVon(st,pTLLWerteSingle(@original.sWerte),xmin,xmax);
- gDouble: dWerte.kopiereVon(st,pTLLWerteDouble(@original.dWerte),xmin,xmax);
- gExtended: eWerte.kopiereVon(st,pTLLWerteExtended(@original.eWerte),xmin,xmax);
+ transformationen:=tIdentitaet.create(original.transformationen);
+ genauigkeit:=original.genauigkeit;
+ case genauigkeit of
+ gSingle: sWerte.kopiereVon(sT,pTLLWerteSingle(@original.sWerte),xMin,xMax);
+ gDouble: dWerte.kopiereVon(sT,pTLLWerteDouble(@original.dWerte),xMin,xMax);
+ gExtended: eWerte.kopiereVon(sT,pTLLWerteExtended(@original.eWerte),xMin,xMax);
end{of case};
end;
@@ -586,147 +587,147 @@ begin
end{of case};
end;
-function tWerte.rXsteps: longint;
+function tWerte.rXSteps: longint;
begin
case genauigkeit of
- gSingle: result:=sWerte.params.xsteps;
- gDouble: result:=dWerte.params.xsteps;
- gExtended: result:=eWerte.params.xsteps;
+ gSingle: result:=sWerte.params.xSteps;
+ gDouble: result:=dWerte.params.xSteps;
+ gExtended: result:=eWerte.params.xSteps;
end{of case};
end;
-procedure tWerte.wXsteps(xs: longint);
+procedure tWerte.wXSteps(xS: longint);
begin
- sWerte.params.xsteps:=xs;
+ sWerte.params.xSteps:=xS;
sWerte.params.refreshKnownValues;
- dWerte.params.xsteps:=xs;
+ dWerte.params.xSteps:=xS;
dWerte.params.refreshKnownValues;
- eWerte.params.xsteps:=xs;
+ eWerte.params.xSteps:=xS;
eWerte.params.refreshKnownValues;
end;
-function tWerte.rTsiz: longint;
+function tWerte.rTSiz: longint;
begin
case genauigkeit of
- gSingle: result:=sWerte.params.tsiz;
- gDouble: result:=dWerte.params.tsiz;
- gExtended: result:=eWerte.params.tsiz;
+ gSingle: result:=sWerte.params.tSiz;
+ gDouble: result:=dWerte.params.tSiz;
+ gExtended: result:=eWerte.params.tSiz;
end{of case};
end;
-procedure tWerte.wTsiz(ts: longint);
+procedure tWerte.wTSiz(tS: longint);
begin
- sWerte.params.tsiz:=ts;
+ sWerte.params.tSiz:=tS;
sWerte.params.refreshKnownValues;
- dWerte.params.tsiz:=ts;
+ dWerte.params.tSiz:=tS;
dWerte.params.refreshKnownValues;
- eWerte.params.tsiz:=ts;
+ eWerte.params.tSiz:=tS;
eWerte.params.refreshKnownValues;
end;
-function tWerte.rXstart: extended;
+function tWerte.rXStart: extended;
begin
case genauigkeit of
- gSingle: result:=sWerte.params.xstart;
- gDouble: result:=dWerte.params.xstart;
- gExtended: result:=eWerte.params.xstart;
+ gSingle: result:=sWerte.params.xStart;
+ gDouble: result:=dWerte.params.xStart;
+ gExtended: result:=eWerte.params.xStart;
end{of case};
end;
-procedure tWerte.wXstart(xs: extended);
+procedure tWerte.wXStart(xS: extended);
begin
case genauigkeit of
gSingle: begin
- sWerte.params.transformationen.xstart:=xs;
+ sWerte.params.transformationen.xStart:=xS;
sWerte.params.refreshKnownValues;
end;
gDouble: begin
- dWerte.params.transformationen.xstart:=xs;
+ dWerte.params.transformationen.xStart:=xS;
dWerte.params.refreshKnownValues;
end;
gExtended: begin
- eWerte.params.transformationen.xstart:=xs;
+ eWerte.params.transformationen.xStart:=xS;
eWerte.params.refreshKnownValues;
end;
end{of case};
end;
-function tWerte.rXstop: extended;
+function tWerte.rXStop: extended;
begin
case genauigkeit of
- gSingle: result:=sWerte.params.xstop;
- gDouble: result:=dWerte.params.xstop;
- gExtended: result:=eWerte.params.xstop;
+ gSingle: result:=sWerte.params.xStop;
+ gDouble: result:=dWerte.params.xStop;
+ gExtended: result:=eWerte.params.xStop;
end{of case};
end;
-procedure tWerte.wXstop(xs: extended);
+procedure tWerte.wXStop(xS: extended);
begin
case genauigkeit of
gSingle: begin
- sWerte.params.transformationen.xstop:=xs;
+ sWerte.params.transformationen.xStop:=xS;
sWerte.params.refreshKnownValues;
end;
gDouble: begin
- dWerte.params.transformationen.xstop:=xs;
+ dWerte.params.transformationen.xStop:=xS;
dWerte.params.refreshKnownValues;
end;
gExtended: begin
- eWerte.params.transformationen.xstop:=xs;
+ eWerte.params.transformationen.xStop:=xS;
eWerte.params.refreshKnownValues;
end;
end{of case};
end;
-function tWerte.rTstart: extended;
+function tWerte.rTStart: extended;
begin
case genauigkeit of
- gSingle: result:=sWerte.params.tstart;
- gDouble: result:=dWerte.params.tstart;
- gExtended: result:=eWerte.params.tstart;
+ gSingle: result:=sWerte.params.tStart;
+ gDouble: result:=dWerte.params.tStart;
+ gExtended: result:=eWerte.params.tStart;
end{of case};
end;
-procedure tWerte.wTstart(ts: extended);
+procedure tWerte.wTStart(tS: extended);
begin
case genauigkeit of
gSingle: begin
- sWerte.params.transformationen.tstart:=ts;
+ sWerte.params.transformationen.tStart:=tS;
sWerte.params.refreshKnownValues;
end;
gDouble: begin
- dWerte.params.transformationen.tstart:=ts;
+ dWerte.params.transformationen.tStart:=tS;
dWerte.params.refreshKnownValues;
end;
gExtended: begin
- eWerte.params.transformationen.tstart:=ts;
+ eWerte.params.transformationen.tStart:=tS;
eWerte.params.refreshKnownValues;
end;
end{of case};
end;
-function tWerte.rTstop: extended;
+function tWerte.rTStop: extended;
begin
case genauigkeit of
- gSingle: result:=sWerte.params.tstop;
- gDouble: result:=dWerte.params.tstop;
- gExtended: result:=eWerte.params.tstop;
+ gSingle: result:=sWerte.params.tStop;
+ gDouble: result:=dWerte.params.tStop;
+ gExtended: result:=eWerte.params.tStop;
end{of case};
end;
-procedure tWerte.wTstop(ts: extended);
+procedure tWerte.wTStop(tS: extended);
begin
case genauigkeit of
gSingle: begin
- sWerte.params.transformationen.tstop:=ts;
+ sWerte.params.transformationen.tStop:=tS;
sWerte.params.refreshKnownValues;
end;
gDouble: begin
- dWerte.params.transformationen.tstop:=ts;
+ dWerte.params.transformationen.tStop:=tS;
dWerte.params.refreshKnownValues;
end;
gExtended: begin
- eWerte.params.transformationen.tstop:=ts;
+ eWerte.params.transformationen.tStop:=tS;
eWerte.params.refreshKnownValues;
end;
end{of case};
@@ -786,57 +787,57 @@ begin
end{of case};
end;
-function tWerte.rMinw: extended;
+function tWerte.rMinW: extended;
begin
case genauigkeit of
- gSingle: result:=sWerte.params.minw;
- gDouble: result:=dWerte.params.minw;
- gExtended: result:=eWerte.params.minw;
+ gSingle: result:=sWerte.params.minW;
+ gDouble: result:=dWerte.params.minW;
+ gExtended: result:=eWerte.params.minW;
end{of case};
end;
-procedure tWerte.wMinw(miw: extended);
+procedure tWerte.wMinW(miW: extended);
begin
- Transformationen.wmin:=miw;
+ transformationen.wMin:=miW;
case genauigkeit of
gSingle: begin
- sWerte.params.minw:=miw;
+ sWerte.params.minW:=miW;
sWerte.params.refreshKnownValues;
end;
gDouble: begin
- dWerte.params.minw:=miw;
+ dWerte.params.minW:=miW;
dWerte.params.refreshKnownValues;
end;
gExtended: begin
- eWerte.params.minw:=miw;
+ eWerte.params.minW:=miW;
eWerte.params.refreshKnownValues;
end;
end{of case};
end;
-function tWerte.rMaxw: extended;
+function tWerte.rMaxW: extended;
begin
case genauigkeit of
- gSingle: result:=sWerte.params.maxw;
- gDouble: result:=dWerte.params.maxw;
- gExtended: result:=eWerte.params.maxw;
+ gSingle: result:=sWerte.params.maxW;
+ gDouble: result:=dWerte.params.maxW;
+ gExtended: result:=eWerte.params.maxW;
end{of case};
end;
-procedure tWerte.wMaxw(maw: extended);
+procedure tWerte.wMaxW(maW: extended);
begin
- Transformationen.wmax:=maw;
+ transformationen.wMax:=maW;
case genauigkeit of
gSingle: begin
- sWerte.params.maxw:=maw;
+ sWerte.params.maxW:=maW;
sWerte.params.refreshKnownValues;
end;
gDouble: begin
- dWerte.params.maxw:=maw;
+ dWerte.params.maxW:=maW;
dWerte.params.refreshKnownValues;
end;
gExtended: begin
- eWerte.params.maxw:=maw;
+ eWerte.params.maxW:=maW;
eWerte.params.refreshKnownValues;
end;
end{of case};
@@ -846,21 +847,21 @@ function tWerte.findeAlleDateien(nam: string; var dat: tGenerischeInputDateiInfo
var
err: longint;
i: longint;
- sr: tSearchRec;
- sa: tMyStringList;
+ sR: tSearchRec;
+ sA: tMyStringList;
begin
result:=false;
- shellExpand(nam,sa);
- for i:=0 to sa.count-1 do begin
- err:=findfirst(sa[i],$3f,sr);
+ shellExpand(nam,sA);
+ for i:=0 to sA.count-1 do begin
+ err:=findFirst(sA[i],$3f,sR);
if err<>0 then begin
- findclose(sr);
- sa.free;
- gibAus('Keine Datei passt zum Muster '''+sa[i]+'''!',3);
+ findClose(sR);
+ sA.free;
+ gibAus('Keine Datei passt zum Muster '''+sA[i]+'''!',3);
exit;
end;
while err=0 do begin
- setlength(dat,length(dat)+1);
+ setLength(dat,length(dat)+1);
if Vorlage is tTraceInputDateiInfo then
dat[length(dat)-1]:=tTraceInputDateiInfo.create(Vorlage);
if Vorlage is tPhaseSpaceInputDateiInfo then
@@ -869,53 +870,53 @@ begin
dat[length(dat)-1]:=tSpaceTimeInputDateiInfo.create(Vorlage);
if Vorlage is tPipeInputDateiInfo then
dat[length(dat)-1]:=tPipeInputDateiInfo.create(Vorlage);
- dat[length(dat)-1].Name:=extractfilepath(nam)+extractfilename(sr.Name);
- err:=findnext(sr);
+ dat[length(dat)-1].name:=extractfilepath(nam)+extractfilename(sR.name);
+ err:=findNext(sR);
end;
- findclose(sr);
+ findClose(sR);
end;
- sa.free;
+ sA.free;
result:=true;
end;
-function tWerte.ermittleExterneInputParameter(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;
ne,be,maxAmp: extended;
- Vorlagen: tInputDateiInfoVorlagen;
+ vorlagen: tInputDateiInfoVorlagen;
g: textfile;
- erfolg: Word;
- i: Longint;
+ erfolg: word;
+ i: longint;
mitGewalt: boolean;
bekannteBefehle: tMyStringList;
procedure aufraeumen;
var
ii: longint;
begin
- if assigned(Vorlagen) then Vorlagen.free;
+ if assigned(vorlagen) then vorlagen.free;
for ii:=0 to length(dateien)-1 do
if assigned(dateien[ii]) then
dateien[ii].free;
- setlength(dateien,0);
+ setLength(dateien,0);
bekannteBefehle.free;
end;
begin
result:=false;
- setlength(dateien,0);
- Vorlagen:=tInputDateiInfoVorlagen.create;
- Vorlagen.params:=sWerte.params;
+ setLength(dateien,0);
+ vorlagen:=tInputDateiInfoVorlagen.create;
+ vorlagen.params:=sWerte.params;
ne:=0;
maxAmp:=0;
sWerte.params.beta:=-1;
sWerte.params.maxW:=0;
sWerte.params.minW:=0;
sWerte.params.np:=0;
- sWerte.params.transformationen.tstart:=0;
- sWerte.params.transformationen.tstop:=0;
- sWerte.params.transformationen.xstart:=0;
- sWerte.params.transformationen.xstop:=0;
+ sWerte.params.transformationen.tStart:=0;
+ sWerte.params.transformationen.tStop:=0;
+ sWerte.params.transformationen.xStart:=0;
+ sWerte.params.transformationen.xStop:=0;
bekannteBefehle:=tMyStringList.create;
mitGewalt:=false;
repeat
@@ -932,67 +933,67 @@ begin
continue;
end;
if istDasBefehl('Genauigkeit:',s,bekannteBefehle,true) then begin
- if not Vorlagen.GenauigkeitFromStr(s) then begin
+ if not vorlagen.genauigkeitFromStr(s) then begin
aufraeumen;
exit;
end;
- if (Genauigkeit < Vorlagen.Genauigkeit) then
- Genauigkeit:=Vorlagen.Genauigkeit;
+ if (genauigkeit < vorlagen.genauigkeit) then
+ genauigkeit:=vorlagen.genauigkeit;
continue;
end;
if istDasBefehl('Gamma:',s,bekannteBefehle,true) then begin
- Vorlagen.Gamma:=exprtofloat(false,s);
+ vorlagen.gamma:=exprToFloat(false,s);
continue;
end;
- if istDasBefehl('tmin:',s,bekannteBefehle,true) then begin
- Vorlagen.tstart:=exprtofloat(false,s);
+ if istDasBefehl('tMin:',s,bekannteBefehle,true) then begin
+ vorlagen.tStart:=exprToFloat(false,s);
continue;
end;
- if istDasBefehl('tmax:',s,bekannteBefehle,true) then begin
- Vorlagen.tstop:=exprtofloat(false,s);
+ if istDasBefehl('tMax:',s,bekannteBefehle,true) then begin
+ vorlagen.tStop:=exprToFloat(false,s);
continue;
end;
- if istDasBefehl('xmin:',s,bekannteBefehle,true) then begin
- Vorlagen.xstart:=exprtofloat(false,s);
+ if istDasBefehl('xMin:',s,bekannteBefehle,true) then begin
+ vorlagen.xStart:=exprToFloat(false,s);
continue;
end;
- if istDasBefehl('xmax:',s,bekannteBefehle,true) then begin
- Vorlagen.xstop:=exprtofloat(false,s);
+ if istDasBefehl('xMax:',s,bekannteBefehle,true) then begin
+ vorlagen.xStop:=exprToFloat(false,s);
continue;
end;
if istDasBefehl('Inputparameterdatei:',s,bekannteBefehle,true) then begin
if (not mitGewalt) and (not fileexists(extractfilepath(s)+'times-1')) and
- ((Vorlagen.Fehlerbehebungskommando='') or
- (sysutils.ExecuteProcess(Vorlagen.Fehlerbehebungsprogramm,Vorlagen.Fehlerbehebungsparameter,[])<>0) or
+ ((vorlagen.fehlerBehebungsKommando='') or
+ (sysutils.executeProcess(vorlagen.fehlerBehebungsProgramm,vorlagen.fehlerBehebungsParameter,[])<>0) or
not fileexists(extractfilepath(s)+'times-1')) then begin
gibAus('Die Simulation in '''+extractfilepath(s)+''' ist nicht abgeschlossen!',3);
aufraeumen;
exit;
end;
- assignfile(g,s);
+ assignFile(g,s);
reset(g);
erfolg:=0;
while not eof(g) do begin
readln(g,s);
s:=erstesArgument(s,'#');
if startetMit('Gamma :',s) then begin
- Vorlagen.Gamma:=strtofloat(s);
+ vorlagen.gamma:=strToFloat(s);
erfolg:=erfolg or 1;
continue;
end;
if startetMit('Beta :',s) then begin
- be:=strtofloat(s);
+ be:=strToFloat(s);
erfolg:=erfolg or 2;
continue;
end;
if startetMit('n_el_over_nc :',s) then begin
- ne:=strtofloat(s);
+ ne:=strToFloat(s);
erfolg:=erfolg or 4;
continue;
end;
if startetMit('.a0 :',s) then begin
- if strtofloat(s)>maxAmp then begin
- maxAmp:=strtofloat(s);
+ if strToFloat(s)>maxAmp then begin
+ maxAmp:=strToFloat(s);
erfolg:=erfolg or 8;
end;
continue;
@@ -1002,7 +1003,7 @@ begin
continue;
end;
if odd(erfolg shr 3) and startetMit('.frequency :',s) then begin
- Vorlagen.groeszenFaktor:=strtofloat(s);
+ vorlagen.groeszenFaktor:=strToFloat(s);
erfolg:=erfolg and (not 8);
continue;
end;
@@ -1013,15 +1014,15 @@ begin
aufraeumen;
exit;
end;
- ne:=sqrt(ne)/Vorlagen.groeszenFaktor;
+ ne:=sqrt(ne)/vorlagen.groeszenFaktor;
if (sWerte.params.np<>0) and (ne<>sWerte.params.np) then begin
- gibAus('Die Plasmafrequenzen in den Eingangsdateien unterscheiden sich ('+floattostr(sWerte.params.np)+' vs. '+floattostr(ne)+')!',3);
+ gibAus('Die Plasmafrequenzen in den Eingangsdateien unterscheiden sich ('+floatToStr(sWerte.params.np)+' vs. '+floatToStr(ne)+')!',3);
aufraeumen;
exit;
end;
sWerte.params.np:=ne;
if (sWerte.params.beta<>-1) and (be<>sWerte.params.beta) then begin
- gibAus('Die Bezugssystemgeschwindigkeiten in den Eingangsdateien unterscheiden sich ('+floattostr(sWerte.params.beta)+' vs. '+floattostr(be)+')!',3);
+ gibAus('Die Bezugssystemgeschwindigkeiten in den Eingangsdateien unterscheiden sich ('+floatToStr(sWerte.params.beta)+' vs. '+floatToStr(be)+')!',3);
aufraeumen;
exit;
end;
@@ -1029,41 +1030,41 @@ begin
continue;
end;
if istDasBefehl('Fehlerbehebungskommando:',s,bekannteBefehle,true) then begin
- Vorlagen.Fehlerbehebungskommando:=s;
+ vorlagen.fehlerBehebungsKommando:=s;
continue;
end;
if istDasBefehl('Spurnummer:',s,bekannteBefehle,true) then begin
- Vorlagen.SpurNummer:=strtoint(s);
+ vorlagen.spurNummer:=strtoint(s);
continue;
end;
if istDasBefehl('Feldnummer:',s,bekannteBefehle,true) then begin
- Vorlagen.FeldNummer:=strtoint(s);
+ vorlagen.feldNummer:=strtoint(s);
continue;
end;
if istDasBefehl('Feld:',s,bekannteBefehle,true) then begin
- Vorlagen.FeldNummer:=-1;
- for i:=0 to length(FeldgroeszenNamen)-1 do
- if uppercase(s)=FeldgroeszenNamen[i] then begin
- Vorlagen.FeldNummer:=i;
+ vorlagen.feldNummer:=-1;
+ for i:=0 to length(feldGroeszenNamen)-1 do
+ if uppercase(s)=feldGroeszenNamen[i] then begin
+ vorlagen.feldNummer:=i;
break;
end;
- if Vorlagen.FeldNummer>=0 then continue;
+ if vorlagen.feldNummer>=0 then continue;
gibAus('Unbekannte Feldgröße '''+s+'''!',3);
aufraeumen;
exit;
end;
if istDasBefehl('Analysator:',s,bekannteBefehle,true) then begin
- Vorlagen.Analysator:=s;
+ vorlagen.analysator:=s;
continue;
end;
if istDasBefehl('PhaseSpace-Datei:',s,bekannteBefehle,true) then begin
if fileexists(s) then begin
- setlength(dateien,length(dateien)+1);
- dateien[length(dateien)-1]:=tPhaseSpaceInputDateiInfo.create(Vorlagen.PhaseSpaceVorlage);
- dateien[length(dateien)-1].Name:=s;
+ setLength(dateien,length(dateien)+1);
+ dateien[length(dateien)-1]:=tPhaseSpaceInputDateiInfo.create(vorlagen.phaseSpaceVorlage);
+ dateien[length(dateien)-1].name:=s;
continue;
end;
- if not findeAlleDateien(s,dateien,Vorlagen.PhaseSpaceVorlage) then begin
+ if not findeAlleDateien(s,dateien,vorlagen.phaseSpaceVorlage) then begin
aufraeumen;
exit;
end;
@@ -1071,12 +1072,12 @@ begin
end;
if istDasBefehl('SpaceTime-Datei:',s,bekannteBefehle,true) then begin
if fileexists(s) then begin
- setlength(dateien,length(dateien)+1);
- dateien[length(dateien)-1]:=tSpaceTimeInputDateiInfo.create(Vorlagen.SpaceTimeVorlage);
- dateien[length(dateien)-1].Name:=s;
+ setLength(dateien,length(dateien)+1);
+ dateien[length(dateien)-1]:=tSpaceTimeInputDateiInfo.create(vorlagen.spaceTimeVorlage);
+ dateien[length(dateien)-1].name:=s;
continue;
end;
- if not findeAlleDateien(s,dateien,Vorlagen.SpaceTimeVorlage) then begin
+ if not findeAlleDateien(s,dateien,vorlagen.spaceTimeVorlage) then begin
aufraeumen;
exit;
end;
@@ -1084,12 +1085,12 @@ begin
end;
if istDasBefehl('Trace-Datei:',s,bekannteBefehle,true) then begin
if fileexists(s) then begin
- setlength(dateien,length(dateien)+1);
- dateien[length(dateien)-1]:=tTraceInputDateiInfo.create(Vorlagen.TraceVorlage);
- dateien[length(dateien)-1].Name:=s;
+ setLength(dateien,length(dateien)+1);
+ dateien[length(dateien)-1]:=tTraceInputDateiInfo.create(vorlagen.traceVorlage);
+ dateien[length(dateien)-1].name:=s;
continue;
end;
- if not findeAlleDateien(s,dateien,Vorlagen.TraceVorlage) then begin
+ if not findeAlleDateien(s,dateien,vorlagen.traceVorlage) then begin
aufraeumen;
exit;
end;
@@ -1101,25 +1102,25 @@ begin
aufraeumen;
exit;
end;
- setlength(dateien,length(dateien)+1);
- dateien[length(dateien)-1]:=tSergeyInputDateiInfo.create(Vorlagen.SergeyVorlage);
- dateien[length(dateien)-1].Name:=s;
+ setLength(dateien,length(dateien)+1);
+ dateien[length(dateien)-1]:=tSergeyInputDateiInfo.create(vorlagen.sergeyVorlage);
+ dateien[length(dateien)-1].name:=s;
continue;
end;
if istDasBefehl('Pipe:',s,bekannteBefehle,true) then begin
- setlength(dateien,length(dateien)+1);
- dateien[length(dateien)-1]:=tPipeInputDateiInfo.create(Vorlagen.PipeVorlage);
- dateien[length(dateien)-1].Name:=s;
+ setLength(dateien,length(dateien)+1);
+ dateien[length(dateien)-1]:=tPipeInputDateiInfo.create(vorlagen.pipeVorlage);
+ dateien[length(dateien)-1].name:=s;
continue;
end;
if istDasBefehl('Andor-Datei:',s,bekannteBefehle,true) then begin
if fileexists(s) then begin
- setlength(dateien,length(dateien)+1);
- dateien[length(dateien)-1]:=tAndorInputDateiInfo.create(Vorlagen.AndorVorlage);
- dateien[length(dateien)-1].Name:=s;
+ setLength(dateien,length(dateien)+1);
+ dateien[length(dateien)-1]:=tAndorInputDateiInfo.create(vorlagen.andorVorlage);
+ dateien[length(dateien)-1].name:=s;
continue;
end;
- if not findeAlleDateien(s,dateien,Vorlagen.AndorVorlage) then begin
+ if not findeAlleDateien(s,dateien,vorlagen.andorVorlage) then begin
aufraeumen;
exit;
end;
@@ -1131,67 +1132,67 @@ begin
exit;
until false;
sWerte.params.refreshKnownValues;
- Vorlagen.free;
+ vorlagen.free;
result:=true;
end;
-function tWerte.ermittleInterneInputParameter(var Dateien: tGenerischeInputDateiInfoArray): boolean;
+function tWerte.ermittleInterneInputParameter(var dateien: tGenerischeInputDateiInfoArray): boolean;
// Parameter ermitteln, die aus der einzulesenden Datei hervorgehen
var
- i,j,k,num,tmpi,br,SpAnz: longint;
- tmps: single;
- tmpd: double;
- tmpe: extended;
+ i,j,k,num,tmpI,br,spAnz: longint;
+ tmpS: single;
+ tmpD: double;
+ tmpE: extended;
f: file;
tf: textfile;
- Positionen,iArr: tLongintArray;
- Sortiert: tGenerischeInputDateiInfoArray;
- ipp,ipap: tProcess;
+ positionen,iArr: tLongintArray;
+ sortiert: tGenerischeInputDateiInfoArray;
+ iPP,iPAP: tProcess;
buf: array of byte;
s,t: string;
sl: tMyStringList;
begin
result:=false;
- if length(Dateien)=0 then begin
+ if length(dateien)=0 then begin
gibAus('Keine Dateien zum Einlesen!',3);
exit;
end;
- tmpi:=0;
+ tmpI:=0;
num:=0;
- tmps:=0;
- tmpd:=0;
- SpAnz:=-1;
- setlength(Positionen,length(dateien));
- for i:=0 to length(Positionen)-1 do
- Positionen[i]:=-1;
+ tmpS:=0;
+ tmpD:=0;
+ spAnz:=-1;
+ setLength(positionen,length(dateien));
+ for i:=0 to length(positionen)-1 do
+ positionen[i]:=-1;
for i:=0 to length(dateien)-1 do begin
if dateien[i] is tPipeInputDateiInfo then begin
- ipp:=tProcess.create(nil); // dieser Prozess generiert die Daten
- ipp.Executable:=(dateien[i] as tPipeInputDateiInfo).Executable;
- ipp.Parameters.Text:=(dateien[i] as tPipeInputDateiInfo).ParametersText;
- ipp.Options:=ipp.Options + [poUsePipes];
- ipap:=tProcess.create(nil); // dieser Prozess analysiert die Daten
- ipap.Executable:=(dateien[i] as tPipeInputDateiInfo).AnalysatorExecutable;
- ipap.Parameters.Text:=(dateien[i] as tPipeInputDateiInfo).AnalysatorParametersText;
- ipap.Options:=ipp.Options + [poUsePipes];
- ipp.execute;
- ipap.execute;
+ iPP:=tProcess.create(nil); // dieser Prozess generiert die Daten
+ iPP.executable:=(dateien[i] as tPipeInputDateiInfo).executable;
+ iPP.parameters.text:=(dateien[i] as tPipeInputDateiInfo).parametersText;
+ iPP.options:=iPP.options + [poUsePipes];
+ iPAP:=tProcess.create(nil); // dieser Prozess analysiert die Daten
+ iPAP.executable:=(dateien[i] as tPipeInputDateiInfo).analysatorExecutable;
+ iPAP.parameters.text:=(dateien[i] as tPipeInputDateiInfo).analysatorParametersText;
+ iPAP.options:=iPP.options + [poUsePipes];
+ iPP.execute;
+ iPAP.execute;
s:='';
br:=0;
- while (ipp.running or (ipp.Output.NumBytesAvailable > 0)) and ipap.running do begin
- if ipap.Output.NumBytesAvailable>0 then begin
- setlength(s,br+ipap.Output.NumBytesAvailable);
- br:=br+ipap.Output.Read(s[br+1],length(s)-br);
+ while (iPP.running or (iPP.output.numBytesAvailable > 0)) and iPAP.running do begin
+ if iPAP.output.numBytesAvailable>0 then begin
+ setLength(s,br+iPAP.output.numBytesAvailable);
+ br:=br+iPAP.output.read(s[br+1],length(s)-br);
continue;
end;
- if ipp.Output.NumBytesAvailable > 0 then begin
- setlength(buf,ipp.Output.NumBytesAvailable);
- setlength(buf,ipp.Output.Read(buf[0],length(buf)));
+ if iPP.output.numBytesAvailable > 0 then begin
+ setLength(buf,iPP.output.numBytesAvailable);
+ setLength(buf,iPP.output.read(buf[0],length(buf)));
j:=0;
k:=-1;
while (j<length(buf)) and (k<>0) do begin
- k:=ipap.Input.Write(buf[j],length(buf)-j);
+ k:=iPAP.Input.write(buf[j],length(buf)-j);
j:=j+k;
end;
sleep(100); // SEHR DRECKIG !!!
@@ -1200,31 +1201,31 @@ begin
sleep(10);
end;
- if not ipap.running then
- ipp.CloseOutput;
- if not ipp.running then
- ipap.CloseInput;
+ if not iPAP.running then
+ iPP.CloseOutput;
+ if not iPP.running then
+ iPAP.CloseInput;
- setlength(buf,0);
+ setLength(buf,0);
- while ipap.running or (ipap.Output.NumBytesAvailable>0) do begin
- setlength(s,br+ipap.Output.NumBytesAvailable);
- br:=br+ipap.Output.Read(s[br+1],length(s)-br);
- if ipap.running then
+ while iPAP.running or (iPAP.output.numBytesAvailable>0) do begin
+ setLength(s,br+iPAP.output.numBytesAvailable);
+ br:=br+iPAP.output.read(s[br+1],length(s)-br);
+ if iPAP.running then
sleep(10);
end;
- if not ipp.waitOnExit then begin
- gibAus('ErmittleInterneInputParameter hat ohne Erfolg auf Ende von ipp gewartet!',3);
+ if not iPP.waitOnExit then begin
+ gibAus('ErmittleInterneInputParameter hat ohne Erfolg auf Ende von iPP gewartet!',3);
exit;
end;
- if not ipap.waitOnExit then begin
- gibAus('ErmittleInterneInputParameter hat ohne Erfolg auf Ende von ipap gewartet!',3);
+ if not iPAP.waitOnExit then begin
+ gibAus('ErmittleInterneInputParameter hat ohne Erfolg auf Ende von iPAP gewartet!',3);
exit;
end;
- ipp.free;
- ipap.free;
+ iPP.free;
+ iPAP.free;
dateien[i].groeszenFaktor:=1;
@@ -1236,11 +1237,11 @@ begin
delete(s,1,length(t)+1);
t:=trim(t);
if startetMit('Channels',t) and startetMit(':',t) then begin
- dateien[i].xsteps:=strtoint(t);
+ dateien[i].xSteps:=strtoint(t);
continue;
end;
if startetMit('Sample Rate',t) and startetMit(':',t) then begin
- dateien[i].groeszenFaktor:=dateien[i].groeszenFaktor/strtofloat(t);
+ dateien[i].groeszenFaktor:=dateien[i].groeszenFaktor/strToFloat(t);
continue;
end;
if startetMit('Precision',t) and startetMit(':',t) then begin
@@ -1249,14 +1250,14 @@ begin
exit;
end;
delete(t,length(t)-3,4);
- (dateien[i] as tPipeInputDateiInfo).bytesPerSample:=ceil(strtofloat(trim(t))/8);
+ (dateien[i] as tPipeInputDateiInfo).bytesPerSample:=ceil(strToFloat(trim(t))/8);
continue;
end;
if startetMit('Duration',t) and startetMit(':',t) then begin
erstesArgument(t,'=');
t:=erstesArgument(t);
- dateien[i].tsiz:=strtoint(t);
- dateien[i].groeszenFaktor:=dateien[i].groeszenFaktor*dateien[i].tsiz;
+ dateien[i].tSiz:=strtoint(t);
+ dateien[i].groeszenFaktor:=dateien[i].groeszenFaktor*dateien[i].tSiz;
continue;
end;
if startetMit('Sample Encoding',t) and startetMit(':',t) then begin
@@ -1272,155 +1273,155 @@ begin
repeat
k:=-1;
for j:=0 to i-1 do
- if Positionen[j]=num then begin
+ if positionen[j]=num then begin
inc(k);
inc(num);
end;
until k=-1;
- Positionen[i]:=num;
+ positionen[i]:=num;
end;
if (dateien[i] is tSpaceTimeInputDateiInfo) or
(dateien[i] is tTraceInputDateiInfo) then begin
- assign(f,dateien[i].Name);
+ assign(f,dateien[i].name);
reset(f,1);
- blockread(f,num,sizeof(longint));
+ blockread(f,num,sizeOf(longint));
dec(num);
if dateien[i] is tTraceInputDateiInfo then begin
- dateien[i].xsteps:=1;
- dateien[i].xstop:=dateien[i].xstart;
- blockread(f,tmpi,sizeof(longint));
- if spAnz<0 then spAnz:=tmpi;
- if spAnz<>tmpi then begin
- gibAus('Falsche Anzahl an Spuren ('+inttostr(tmpi)+' statt '+inttostr(spAnz)+') in Datei '''+dateien[i].Name+'''!',3);
+ dateien[i].xSteps:=1;
+ dateien[i].xStop:=dateien[i].xStart;
+ blockread(f,tmpI,sizeOf(longint));
+ if spAnz<0 then spAnz:=tmpI;
+ if spAnz<>tmpI then begin
+ gibAus('Falsche Anzahl an Spuren ('+intToStr(tmpI)+' statt '+intToStr(spAnz)+') in Datei '''+dateien[i].name+'''!',3);
close(f);
exit;
end;
- if ((dateien[i] as TTraceInputDateiInfo).Spurnummer<0) or ((dateien[i] as TTraceInputDateiInfo).Spurnummer>=spAnz) then begin
- gibAus('Ausgewählte Spurnummer ('+inttostr((dateien[i] as TTraceInputDateiInfo).Spurnummer)+') liegt außerhalb des verfügbaren Bereiches (0..'+inttostr(spAnz-1)+')!',3);
+ if ((dateien[i] as tTraceInputDateiInfo).spurNummer<0) or ((dateien[i] as tTraceInputDateiInfo).spurNummer>=spAnz) then begin
+ gibAus('Ausgewählte Spurnummer ('+intToStr((dateien[i] as tTraceInputDateiInfo).spurNummer)+') liegt außerhalb des verfügbaren Bereiches (0..'+intToStr(spAnz-1)+')!',3);
close(f);
exit;
end;
- if ((dateien[i] as TTraceInputDateiInfo).Feldnummer<0) or ((dateien[i] as TTraceInputDateiInfo).Feldnummer>=length(FeldgroeszenNamen)) then begin
- gibAus('Ausgewählte Feldnummer ('+inttostr((dateien[i] as TTraceInputDateiInfo).Feldnummer)+') liegt außerhalb des verfügbaren Bereiches (0..'+inttostr(length(FeldgroeszenNamen)-1)+')!',3);
+ if ((dateien[i] as tTraceInputDateiInfo).feldNummer<0) or ((dateien[i] as tTraceInputDateiInfo).feldNummer>=length(feldGroeszenNamen)) then begin
+ gibAus('Ausgewählte Feldnummer ('+intToStr((dateien[i] as tTraceInputDateiInfo).feldNummer)+') liegt außerhalb des verfügbaren Bereiches (0..'+intToStr(length(feldGroeszenNamen)-1)+')!',3);
close(f);
exit;
end;
end;
- blockread(f,tmpi,sizeof(longint));
- dateien[i].tsiz:=tmpi;
+ blockread(f,tmpI,sizeOf(longint));
+ dateien[i].tSiz:=tmpI;
if dateien[i] is tSpaceTimeInputDateiInfo then begin
- case dateien[i].Genauigkeit of
+ case dateien[i].genauigkeit of
gSingle: begin
- blockread(f,tmps,sizeof(single));
- tmpe:=tmps;
+ blockread(f,tmpS,sizeOf(single));
+ tmpE:=tmpS;
end;
gDouble: begin
- blockread(f,tmpd,sizeof(double));
- tmpe:=tmpd;
+ blockread(f,tmpD,sizeOf(double));
+ tmpE:=tmpD;
end;
- gExtended: blockread(f,tmpe,sizeof(extended));
+ gExtended: blockread(f,tmpE,sizeOf(extended));
end{of case};
- tmpe:=tmpe*dateien[i].groeszenFaktor;
- if i=0 then Transformationen.xstart:=tmpe;
- if tmpe<>Transformationen.xstart then begin
- gibAus('Falscher linker Rand in '''+dateien[i].Name+''', nämlich '+myfloattostr(tmpe)+' statt '+myfloattostr(Transformationen.xstart)+'.',3);
+ tmpE:=tmpE*dateien[i].groeszenFaktor;
+ if i=0 then transformationen.xStart:=tmpE;
+ if tmpE<>transformationen.xStart then begin
+ gibAus('Falscher linker Rand in '''+dateien[i].name+''', nämlich '+myFloatToStr(tmpE)+' statt '+myFloatToStr(transformationen.xStart)+'.',3);
close(f);
exit;
end;
- case dateien[i].Genauigkeit of
+ case dateien[i].genauigkeit of
gSingle: begin
- blockread(f,tmps,sizeof(single));
- tmpe:=tmps;
+ blockread(f,tmpS,sizeOf(single));
+ tmpE:=tmpS;
end;
gDouble: begin
- blockread(f,tmpd,sizeof(double));
- tmpe:=tmpd;
+ blockread(f,tmpD,sizeOf(double));
+ tmpE:=tmpD;
end;
- gExtended: blockread(f,tmpe,sizeof(extended));
+ gExtended: blockread(f,tmpE,sizeOf(extended));
end{of case};
- tmpe:=tmpe*dateien[i].groeszenFaktor;
- if i=0 then Transformationen.xstop:=tmpe;
- if tmpe<>Transformationen.xstop then begin
- gibAus('Falscher rechter Rand in '''+dateien[i].Name+''', nämlich '+myfloattostr(tmpe)+' statt '+myfloattostr(Transformationen.xstop)+'.',3);
+ tmpE:=tmpE*dateien[i].groeszenFaktor;
+ if i=0 then transformationen.xStop:=tmpE;
+ if tmpE<>transformationen.xStop then begin
+ gibAus('Falscher rechter Rand in '''+dateien[i].name+''', nämlich '+myFloatToStr(tmpE)+' statt '+myFloatToStr(transformationen.xStop)+'.',3);
close(f);
exit;
end;
- blockread(f,tmpi,sizeof(longint));
- dateien[i].xsteps:=tmpi;
+ blockread(f,tmpI,sizeOf(longint));
+ dateien[i].xSteps:=tmpI;
end;
close(f);
for j:=0 to i-1 do
- if Positionen[j]=num then begin
- gibAus('Datei '''+dateien[i].Name+''' ist redundant zu '''+dateien[j].Name+'''.',3);
+ if positionen[j]=num then begin
+ gibAus('Datei '''+dateien[i].name+''' ist redundant zu '''+dateien[j].name+'''.',3);
exit;
end;
- Positionen[i]:=num;
+ positionen[i]:=num;
end;
if dateien[i] is tPhaseSpaceInputDateiInfo then begin
if (i<>0) or (length(dateien)<>1) then begin
gibAus('Ich kann Phasenraumdateien nicht kaskadieren!',3);
exit;
end;
- assign(f,dateien[i].Name);
+ assign(f,dateien[i].name);
reset(f,1);
- case dateien[i].Genauigkeit of
+ case dateien[i].genauigkeit of
gSingle: begin
- blockread(f,tmps,sizeof(single));
- tmpe:=tmps;
+ blockread(f,tmpS,sizeOf(single));
+ tmpE:=tmpS;
end;
gDouble: begin
- blockread(f,tmpd,sizeof(double));
- tmpe:=tmpd;
+ blockread(f,tmpD,sizeOf(double));
+ tmpE:=tmpD;
end;
- gExtended: blockread(f,tmpe,sizeof(extended));
+ gExtended: blockread(f,tmpE,sizeOf(extended));
end{of case};
- tmpe:=tmpe*dateien[i].groeszenFaktor;
- Transformationen.tstart:=tmpe;
- case dateien[i].Genauigkeit of
+ tmpE:=tmpE*dateien[i].groeszenFaktor;
+ transformationen.tStart:=tmpE;
+ case dateien[i].genauigkeit of
gSingle: begin
- blockread(f,tmps,sizeof(single));
- tmpe:=tmps;
+ blockread(f,tmpS,sizeOf(single));
+ tmpE:=tmpS;
end;
gDouble: begin
- blockread(f,tmpd,sizeof(double));
- tmpe:=tmpd;
+ blockread(f,tmpD,sizeOf(double));
+ tmpE:=tmpD;
end;
- gExtended: blockread(f,tmpe,sizeof(extended));
+ gExtended: blockread(f,tmpE,sizeOf(extended));
end{of case};
- tmpe:=tmpe*dateien[i].groeszenFaktor;
- Transformationen.tstop:=tmpe;
- blockread(f,tmpi,sizeof(longint));
- dateien[i].tsiz:=tmpi;
- case dateien[i].Genauigkeit of
+ tmpE:=tmpE*dateien[i].groeszenFaktor;
+ transformationen.tStop:=tmpE;
+ blockread(f,tmpI,sizeOf(longint));
+ dateien[i].tSiz:=tmpI;
+ case dateien[i].genauigkeit of
gSingle: begin
- blockread(f,tmps,sizeof(single));
- tmpe:=tmps;
+ blockread(f,tmpS,sizeOf(single));
+ tmpE:=tmpS;
end;
gDouble: begin
- blockread(f,tmpd,sizeof(double));
- tmpe:=tmpd;
+ blockread(f,tmpD,sizeOf(double));
+ tmpE:=tmpD;
end;
- gExtended: blockread(f,tmpe,sizeof(extended));
+ gExtended: blockread(f,tmpE,sizeOf(extended));
end{of case};
- tmpe:=tmpe*dateien[i].groeszenFaktor;
- Transformationen.xstart:=tmpe;
- case dateien[i].Genauigkeit of
+ tmpE:=tmpE*dateien[i].groeszenFaktor;
+ transformationen.xStart:=tmpE;
+ case dateien[i].genauigkeit of
gSingle: begin
- blockread(f,tmps,sizeof(single));
- tmpe:=tmps;
+ blockread(f,tmpS,sizeOf(single));
+ tmpE:=tmpS;
end;
gDouble: begin
- blockread(f,tmpd,sizeof(double));
- tmpe:=tmpd;
+ blockread(f,tmpD,sizeOf(double));
+ tmpE:=tmpD;
end;
- gExtended: blockread(f,tmpe,sizeof(extended));
+ gExtended: blockread(f,tmpE,sizeOf(extended));
end{of case};
- tmpe:=tmpe*dateien[i].groeszenFaktor;
- Transformationen.xstop:=tmpe;
- blockread(f,tmpi,sizeof(longint));
- dateien[i].xsteps:=tmpi;
+ tmpE:=tmpE*dateien[i].groeszenFaktor;
+ transformationen.xStop:=tmpE;
+ blockread(f,tmpI,sizeOf(longint));
+ dateien[i].xSteps:=tmpI;
close(f);
- Positionen[i]:=0;
+ positionen[i]:=0;
end;
if dateien[i] is tSergeyInputDateiInfo then begin
if (i<>0) or (length(dateien)<>1) then begin
@@ -1428,38 +1429,38 @@ begin
exit;
end;
- if rightstr(dateien[i].Name,1)<>'/' then
- dateien[i].Name:=dateien[i].Name+'/';
+ if rightStr(dateien[i].name,1)<>'/' then
+ dateien[i].name:=dateien[i].name+'/';
- if not fileexists(dateien[i].Name+'numberoftimesteps') then begin
- gibAus('Datei '''+dateien[i].Name+'numberoftimesteps'' existiert nicht!',3);
+ if not fileexists(dateien[i].name+'numberoftimesteps') then begin
+ gibAus('Datei '''+dateien[i].name+'numberoftimesteps'' existiert nicht!',3);
exit;
end;
- if not fileexists(dateien[i].Name+'dt') then begin
- gibAus('Datei '''+dateien[i].Name+'dt'' existiert nicht!',3);
+ if not fileexists(dateien[i].name+'dt') then begin
+ gibAus('Datei '''+dateien[i].name+'dt'' existiert nicht!',3);
exit;
end;
- if not fileexists(dateien[i].Name+'traces/traces.dat') then begin
- gibAus('Datei '''+dateien[i].Name+'traces/traces.dat'' existiert nicht!',3);
+ if not fileexists(dateien[i].name+'traces/traces.dat') then begin
+ gibAus('Datei '''+dateien[i].name+'traces/traces.dat'' existiert nicht!',3);
exit;
end;
- if not fileexists(dateien[i].Name+'../xrom.ini') then begin
- gibAus('Datei '''+dateien[i].Name+'../xrom.ini'' existiert nicht!',3);
+ if not fileexists(dateien[i].name+'../xrom.ini') then begin
+ gibAus('Datei '''+dateien[i].name+'../xrom.ini'' existiert nicht!',3);
exit;
end;
- if ((dateien[i] as TSergeyInputDateiInfo).Feldnummer<0) or ((dateien[i] as TSergeyInputDateiInfo).Feldnummer>=anzSergeyFelder) then begin
- gibAus('Ausgewählte Feldnummer ('+inttostr((dateien[i] as TSergeyInputDateiInfo).Feldnummer)+') liegt außerhalb des verfügbaren Bereiches (0..'+inttostr(anzSergeyFelder-1)+')!',3);
+ if ((dateien[i] as tSergeyInputDateiInfo).feldNummer<0) or ((dateien[i] as tSergeyInputDateiInfo).feldNummer>=anzSergeyFelder) then begin
+ gibAus('Ausgewählte Feldnummer ('+intToStr((dateien[i] as tSergeyInputDateiInfo).feldNummer)+') liegt außerhalb des verfügbaren Bereiches (0..'+intToStr(anzSergeyFelder-1)+')!',3);
exit;
end;
- assign(tf,dateien[i].Name+'numberoftimesteps');
+ assign(tf,dateien[i].name+'numberoftimesteps');
reset(tf);
- readln(tf,tmpi);
+ readln(tf,tmpI);
close(tf);
- dateien[i].tsiz:=tmpi+1;
+ dateien[i].tSiz:=tmpI+1;
- sl:=tMyStringlist.create;
- sl.loadFromFile(dateien[i].Name+'../xrom.ini');
+ sl:=tMyStringList.create;
+ sl.loadFromFile(dateien[i].name+'../xrom.ini');
t:=sl.grepFirst('^\s*Pulse[12]\.a0\s*=.*[^0 ].*$');
if t='' then begin
gibAus(''''+s+''' enthält keinen Puls, den ich erkenne!',3);
@@ -1474,83 +1475,83 @@ begin
exit;
end;
erstesArgument(t,'=');
- dateien[i].params.np:=sqrt(strtofloat(t))/dateien[i].groeszenFaktor;
+ dateien[i].params.np:=sqrt(strToFloat(t))/dateien[i].groeszenFaktor;
sl.free;
- assign(tf,dateien[i].Name+'dt');
+ assign(tf,dateien[i].name+'dt');
reset(tf);
- readln(tf,tmpe);
+ readln(tf,tmpE);
close(tf);
- tmpe:=tmpe*dateien[i].groeszenFaktor;
- dateien[i].tstart:=0;
- dateien[i].tstop:=tmpe/2/pi*(dateien[i].tsiz-1);
- dateien[i].xstart:=0;
- dateien[i].xstop:=0;
- dateien[i].xsteps:=1;
-
- assignfile(f,dateien[i].Name+'traces/traces.dat');
+ tmpE:=tmpE*dateien[i].groeszenFaktor;
+ dateien[i].tStart:=0;
+ dateien[i].tStop:=tmpE/2/pi*(dateien[i].tSiz-1);
+ dateien[i].xStart:=0;
+ dateien[i].xStop:=0;
+ dateien[i].xSteps:=1;
+
+ assignFile(f,dateien[i].name+'traces/traces.dat');
reset(f,1);
- if filesize(f)<>wertGroesze(dateien[i].Genauigkeit)*dateien[i].tsiz*anzSergeyFelder then begin
- gibAus(''''+dateien[i].Name+'traces/traces.dat'' hat die falsche Größe ('+inttostr(filesize(f))+' statt '+inttostr(wertGroesze(dateien[i].Genauigkeit)*dateien[i].tsiz*anzSergeyFelder)+' Byte)!',3);
+ if filesize(f)<>wertGroesze(dateien[i].genauigkeit)*dateien[i].tSiz*anzSergeyFelder then begin
+ gibAus(''''+dateien[i].name+'traces/traces.dat'' hat die falsche Größe ('+intToStr(filesize(f))+' statt '+intToStr(wertGroesze(dateien[i].genauigkeit)*dateien[i].tSiz*anzSergeyFelder)+' Byte)!',3);
close(f);
exit;
end;
close(f);
- Positionen[i]:=0;
+ positionen[i]:=0;
end;
if dateien[i] is tAndorInputDateiInfo then begin
if (i<>0) or (length(dateien)<>1) then begin
gibAus('Ich kann Andor-Dateien nicht kaskadieren!',3);
exit;
end;
- assignfile(f,dateien[i].Name);
+ assignFile(f,dateien[i].name);
reset(f,1);
readALine(f,s);
if s<>'Andor Technology Multi-Channel File' then begin
- gibAus('Syntax-Fehler in '''+dateien[i].Name+''': erkenne Andor Datei nicht!',3);
- closefile(f);
+ gibAus('Syntax-Fehler in '''+dateien[i].name+''': erkenne Andor Datei nicht!',3);
+ closeFile(f);
exit;
end;
readALine(f,s);
if s<>'65538 1' then begin
- gibAus('Syntax-Fehler in '''+dateien[i].Name+''': diese Andor Datei hält der strengen Prüfung nicht stand!',3);
- closefile(f);
+ gibAus('Syntax-Fehler in '''+dateien[i].name+''': diese Andor Datei hält der strengen Prüfung nicht stand!',3);
+ closeFile(f);
exit;
end;
readALine(f,s);
for j:=0 to 4 do
erstesArgument(s,' ',false);
- (dateien[i] as TAndorInputDateiInfo).temperatur:=strToFloat(erstesArgument(s,' ',false));
+ (dateien[i] as tAndorInputDateiInfo).temperatur:=strToFloat(erstesArgument(s,' ',false));
for j:=6 to 11 do
erstesArgument(s,' ',false);
- (dateien[i] as TAndorInputDateiInfo).belichtungsZeit:=strToFloat(erstesArgument(s,' ',false));
- (dateien[i] as TAndorInputDateiInfo).zyklusZeit:=strToFloat(erstesArgument(s,' ',false));
- (dateien[i] as TAndorInputDateiInfo).akkumulierteZyklusZeit:=strToFloat(erstesArgument(s,' ',false));
- (dateien[i] as TAndorInputDateiInfo).akkumulierteZyklen:=strToInt64(erstesArgument(s,' ',false));
+ (dateien[i] as tAndorInputDateiInfo).belichtungsZeit:=strToFloat(erstesArgument(s,' ',false));
+ (dateien[i] as tAndorInputDateiInfo).zyklusZeit:=strToFloat(erstesArgument(s,' ',false));
+ (dateien[i] as tAndorInputDateiInfo).akkumulierteZyklusZeit:=strToFloat(erstesArgument(s,' ',false));
+ (dateien[i] as tAndorInputDateiInfo).akkumulierteZyklen:=strToInt64(erstesArgument(s,' ',false));
erstesArgument(s,' ',false); // 16
- (dateien[i] as TAndorInputDateiInfo).zyklusStapelZeit:=strToFloat(erstesArgument(s,' ',false));
- (dateien[i] as TAndorInputDateiInfo).pixelAusleseZeit:=strToFloat(erstesArgument(s,' ',false));
+ (dateien[i] as tAndorInputDateiInfo).zyklusStapelZeit:=strToFloat(erstesArgument(s,' ',false));
+ (dateien[i] as tAndorInputDateiInfo).pixelAusleseZeit:=strToFloat(erstesArgument(s,' ',false));
for j:=19 to 20 do
erstesArgument(s,' ',false);
- (dateien[i] as TAndorInputDateiInfo).verstaerkungADW:=strToFloat(erstesArgument(s,' ',false));
+ (dateien[i] as tAndorInputDateiInfo).verstaerkungADW:=strToFloat(erstesArgument(s,' ',false));
for j:=22 to 75 do
erstesArgument(s,' ',false);
try
- readAnAndorString(f,(dateien[i] as TAndorInputDateiInfo).detektorTyp,strToInt64(s),true);
+ readAnAndorString(f,(dateien[i] as tAndorInputDateiInfo).detektorTyp,strToInt64(s),true);
except
- gibAus('Syntax-Fehler in '''+dateien[i].Name+''': Detektor-String nicht lesbar!',3);
+ gibAus('Syntax-Fehler in '''+dateien[i].name+''': Detektor-String nicht lesbar!',3);
closeFile(f);
exit;
end;
readALine(f,s);
s:=trim(s);
- (dateien[i] as TAndorInputDateiInfo).detektorGroesze['x']:=strToInt64(erstesArgument(s,' ',false));
- (dateien[i] as TAndorInputDateiInfo).detektorGroesze['y']:=strToInt64(erstesArgument(s,' ',false));
+ (dateien[i] as tAndorInputDateiInfo).detektorGroesze['x']:=strToInt64(erstesArgument(s,' ',false));
+ (dateien[i] as tAndorInputDateiInfo).detektorGroesze['y']:=strToInt64(erstesArgument(s,' ',false));
try
- readAnAndorString(f,(dateien[i] as TAndorInputDateiInfo).dateiName,strToInt64(s),true);
+ readAnAndorString(f,(dateien[i] as tAndorInputDateiInfo).dateiName,strToInt64(s),true);
except
- gibAus('Syntax-Fehler in '''+dateien[i].Name+''': originaler Dateiname nicht lesbar!',3);
+ gibAus('Syntax-Fehler in '''+dateien[i].name+''': originaler Dateiname nicht lesbar!',3);
closeFile(f);
exit;
end;
@@ -1561,19 +1562,19 @@ begin
readALine(f,s);
for j:=0 to 2 do
erstesArgument(s,' ',false);
- dateien[i].xstart:=strToFloat(erstesArgument(s,' ',false));
- (dateien[i] as TAndorInputDateiInfo).shutterZeit['x']:=strToFloat(erstesArgument(s,' ',false));
- (dateien[i] as TAndorInputDateiInfo).shutterZeit['y']:=strToFloat(erstesArgument(s,' ',false));
+ dateien[i].xStart:=strToFloat(erstesArgument(s,' ',false));
+ (dateien[i] as tAndorInputDateiInfo).shutterZeit['x']:=strToFloat(erstesArgument(s,' ',false));
+ (dateien[i] as tAndorInputDateiInfo).shutterZeit['y']:=strToFloat(erstesArgument(s,' ',false));
erstesArgument(s,' ',false); // Gitter-abstand?
- dateien[i].xstop:=strToFloat(erstesArgument(s,'nm',false));
- for j:=0 to (dateien[i] as TAndorInputDateiInfo).detectorSkipLines-1 do
+ dateien[i].xStop:=strToFloat(erstesArgument(s,'nm',false));
+ for j:=0 to (dateien[i] as tAndorInputDateiInfo).detectorSkipLines-1 do
readALine(f,s);
try
- readAnAndorString(f,(dateien[i] as TAndorInputDateiInfo).xAchsenTitel,false);
- readAnAndorString(f,(dateien[i] as TAndorInputDateiInfo).datenTypTitel,false);
- readAnAndorString(f,(dateien[i] as TAndorInputDateiInfo).yAchsenTitel,false);
+ readAnAndorString(f,(dateien[i] as tAndorInputDateiInfo).xAchsenTitel,false);
+ readAnAndorString(f,(dateien[i] as tAndorInputDateiInfo).datenTypTitel,false);
+ readAnAndorString(f,(dateien[i] as tAndorInputDateiInfo).yAchsenTitel,false);
except
- gibAus('Syntax-Fehler in '''+dateien[i].Name+''': Achsenbeschriftung nicht lesbar!',3);
+ gibAus('Syntax-Fehler in '''+dateien[i].name+''': Achsenbeschriftung nicht lesbar!',3);
closeFile(f);
exit;
end;
@@ -1581,72 +1582,72 @@ begin
readALine(f,t);
splitStrToInt(s+' '+t,iArr);
if (iArr[0]<>65541) or (iArr[9]<>65538) or (iArr[13]<>1) or (iArr[16]<>0) then begin
- gibAus('Syntax-Fehler in '''+dateien[i].Name+''': inkonsistenter Kopf.',3);
- closefile(f);
+ gibAus('Syntax-Fehler in '''+dateien[i].name+''': inkonsistenter Kopf.',3);
+ closeFile(f);
exit;
end;
- (dateien[i] as TAndorInputDateiInfo).bildBereich['x','x']:=iArr[1];
- (dateien[i] as TAndorInputDateiInfo).bildBereich['x','y']:=iArr[3];
- (dateien[i] as TAndorInputDateiInfo).bildBereich['y','x']:=iArr[4];
- (dateien[i] as TAndorInputDateiInfo).bildBereich['y','y']:=iArr[2];
- (dateien[i] as TAndorInputDateiInfo).bildBereichStapel['x']:=iArr[6];
- (dateien[i] as TAndorInputDateiInfo).bildBereichStapel['y']:=iArr[5];
- (dateien[i] as TAndorInputDateiInfo).rahmenBereich['x','x']:=iArr[10];
- (dateien[i] as TAndorInputDateiInfo).rahmenBereich['x','y']:=iArr[12];
- (dateien[i] as TAndorInputDateiInfo).rahmenBereich['x','x']:=iArr[13];
- (dateien[i] as TAndorInputDateiInfo).rahmenBereich['x','y']:=iArr[11];
- (dateien[i] as TAndorInputDateiInfo).rahmenToepfe['x']:=iArr[15];
- (dateien[i] as TAndorInputDateiInfo).rahmenToepfe['y']:=iArr[14];
-
- j:=(dateien[i] as TAndorInputDateiInfo).bildBereichStapel['y'] -
- (dateien[i] as TAndorInputDateiInfo).bildBereichStapel['x'] + 1;
+ (dateien[i] as tAndorInputDateiInfo).bildBereich['x','x']:=iArr[1];
+ (dateien[i] as tAndorInputDateiInfo).bildBereich['x','y']:=iArr[3];
+ (dateien[i] as tAndorInputDateiInfo).bildBereich['y','x']:=iArr[4];
+ (dateien[i] as tAndorInputDateiInfo).bildBereich['y','y']:=iArr[2];
+ (dateien[i] as tAndorInputDateiInfo).bildBereichStapel['x']:=iArr[6];
+ (dateien[i] as tAndorInputDateiInfo).bildBereichStapel['y']:=iArr[5];
+ (dateien[i] as tAndorInputDateiInfo).rahmenBereich['x','x']:=iArr[10];
+ (dateien[i] as tAndorInputDateiInfo).rahmenBereich['x','y']:=iArr[12];
+ (dateien[i] as tAndorInputDateiInfo).rahmenBereich['x','x']:=iArr[13];
+ (dateien[i] as tAndorInputDateiInfo).rahmenBereich['x','y']:=iArr[11];
+ (dateien[i] as tAndorInputDateiInfo).rahmenToepfe['x']:=iArr[15];
+ (dateien[i] as tAndorInputDateiInfo).rahmenToepfe['y']:=iArr[14];
+
+ j:=(dateien[i] as tAndorInputDateiInfo).bildBereichStapel['y'] -
+ (dateien[i] as tAndorInputDateiInfo).bildBereichStapel['x'] + 1;
if j<>1 then begin
- gibAus('So ein Mist - Ich kenn hier nur den Wert "1" in '''+dateien[i].Name+'''.',3);
+ gibAus('So ein Mist - Ich kenn hier nur den Wert "1" in '''+dateien[i].name+'''.',3);
closeFile(f);
exit;
end;
- dateien[i].xsteps:=
- ((dateien[i] as TAndorInputDateiInfo).bildBereich['x','y']-
- (dateien[i] as TAndorInputDateiInfo).bildBereich['x','x']+1) div
- (dateien[i] as TAndorInputDateiInfo).rahmenToepfe['x'];
- dateien[i].tsiz:=
- ((dateien[i] as TAndorInputDateiInfo).bildBereich['y','y']-
- (dateien[i] as TAndorInputDateiInfo).bildBereich['y','x']+1) div
- (dateien[i] as TAndorInputDateiInfo).rahmenToepfe['y'];
- if (dateien[i].xsteps*dateien[i].tsiz <> iArr[8]) or
+ dateien[i].xSteps:=
+ ((dateien[i] as tAndorInputDateiInfo).bildBereich['x','y']-
+ (dateien[i] as tAndorInputDateiInfo).bildBereich['x','x']+1) div
+ (dateien[i] as tAndorInputDateiInfo).rahmenToepfe['x'];
+ dateien[i].tSiz:=
+ ((dateien[i] as tAndorInputDateiInfo).bildBereich['y','y']-
+ (dateien[i] as tAndorInputDateiInfo).bildBereich['y','x']+1) div
+ (dateien[i] as tAndorInputDateiInfo).rahmenToepfe['y'];
+ if (dateien[i].xSteps*dateien[i].tSiz <> iArr[8]) or
(iArr[8]*j <> iArr[7]) then begin
- gibAus('Syntax-Fehler in '''+dateien[i].Name+''': inkonsistenter Kopf.',3);
- closefile(f);
+ gibAus('Syntax-Fehler in '''+dateien[i].name+''': inkonsistenter Kopf.',3);
+ closeFile(f);
exit;
end;
while j>=0 do begin
readAnAndorString(f,s,false); // labels
dec(j);
end;
- (dateien[i] as TAndorInputDateiInfo).datenStart:=filePos(f);
- seek(f,(dateien[i] as TAndorInputDateiInfo).datenStart+dateien[i].xsteps*dateien[i].tsiz*sizeof(single));
+ (dateien[i] as tAndorInputDateiInfo).datenStart:=filePos(f);
+ seek(f,(dateien[i] as tAndorInputDateiInfo).datenStart+dateien[i].xSteps*dateien[i].tSiz*sizeOf(single));
try
readAnAndorString(f,s,false);
except
s:='falsch';
end;
if s<>'' then begin
- gibAus('Syntax-Fehler in '''+dateien[i].Name+''': vmtl. zu viele/wenige Daten.',3);
- closefile(f);
+ gibAus('Syntax-Fehler in '''+dateien[i].name+''': vmtl. zu viele/wenige Daten.',3);
+ closeFile(f);
exit;
end;
- closefile(f);
+ closeFile(f);
end;
end;
- _tsiz:=0;
- _xsteps:=dateien[0].xsteps;
+ _tSiz:=0;
+ _xSteps:=dateien[0].xSteps;
for i:=0 to length(dateien)-1 do begin
- if dateien[i].xsteps<>_xsteps then begin
- gibAus('Falsche Anzahl an x-Werten in '''+dateien[i].Name+''', nämlich '+inttostr(dateien[i].xsteps)+' statt '+inttostr(_xsteps)+'.',3);
+ if dateien[i].xSteps<>_xSteps then begin
+ gibAus('Falsche Anzahl an x-Werten in '''+dateien[i].name+''', nämlich '+intToStr(dateien[i].xSteps)+' statt '+intToStr(_xSteps)+'.',3);
exit;
end;
- _tsiz:=_tsiz+dateien[i].tsiz;
+ _tSiz:=_tSiz+dateien[i].tSiz;
if dateien[i].groeszenFaktor<>dateien[0].groeszenFaktor then begin
gibAus('Die Dateien haben nicht alle den gleichen Größenfaktor!',3);
exit;
@@ -1655,39 +1656,39 @@ begin
if (dateien[0] is tSergeyInputDateiInfo) or
(dateien[0] is tAndorInputDateiInfo) then begin
- transformationen.xstart:=Dateien[0].xstart;
- transformationen.xstop:=Dateien[0].xstop;
- transformationen.tstart:=Dateien[0].tstart;
- transformationen.tstop:=Dateien[0].tstop;
+ transformationen.xStart:=dateien[0].xStart;
+ transformationen.xStop:=dateien[0].xStop;
+ transformationen.tStart:=dateien[0].tStart;
+ transformationen.tStop:=dateien[0].tStop;
end;
if not ((dateien[0] is tPhaseSpaceInputDateiInfo) or (dateien[0] is tSergeyInputDateiInfo)) then begin
- Transformationen.tstart:=Positionen[0]*dateien[0].groeszenFaktor;
- Transformationen.tstop:=(Positionen[0]+1)*dateien[0].groeszenFaktor;
- for i:=1 to length(Positionen)-1 do begin
- Transformationen.tstart:=min(Transformationen.tstart,Positionen[i]*dateien[i].groeszenFaktor);
- Transformationen.tstop:=max(Transformationen.tstop,(Positionen[i]+1)*dateien[i].groeszenFaktor);
- end;
- if 0<>round(Transformationen.tstart+length(dateien)*dateien[0].groeszenFaktor-Transformationen.tstop) then begin
- gibAus('Die Dateien decken nicht den kompletten Zeitbereich von '+inttostr(round(Transformationen.tstart))+'T bis '+inttostr(round(Transformationen.tstop))+'T ab!',3);
+ transformationen.tStart:=positionen[0]*dateien[0].groeszenFaktor;
+ transformationen.tStop:=(positionen[0]+1)*dateien[0].groeszenFaktor;
+ for i:=1 to length(positionen)-1 do begin
+ transformationen.tStart:=min(transformationen.tStart,positionen[i]*dateien[i].groeszenFaktor);
+ transformationen.tStop:=max(transformationen.tStop,(positionen[i]+1)*dateien[i].groeszenFaktor);
+ end;
+ if 0<>round(transformationen.tStart+length(dateien)*dateien[0].groeszenFaktor-transformationen.tStop) then begin
+ gibAus('Die Dateien decken nicht den kompletten Zeitbereich von '+intToStr(round(transformationen.tStart))+'T bis '+intToStr(round(transformationen.tStop))+'T ab!',3);
exit;
end;
- setlength(sortiert,length(dateien));
- for i:=0 to length(Positionen)-1 do
- sortiert[Positionen[i]-round(Transformationen.tstart/dateien[i].groeszenFaktor)]:=dateien[i];
- for i:=0 to length(Positionen)-1 do begin
+ setLength(sortiert,length(dateien));
+ for i:=0 to length(positionen)-1 do
+ sortiert[positionen[i]-round(transformationen.tStart/dateien[i].groeszenFaktor)]:=dateien[i];
+ for i:=0 to length(positionen)-1 do begin
dateien[i]:=sortiert[i];
if i=0 then begin
- dateien[i].t0abs:=0;
- sWerte.params.tsiz_:=dateien[i].tmax-dateien[i].tmin+1;
- sWerte.params.xsteps_:=dateien[i].xmax-dateien[i].xmin+1;
+ dateien[i].t0Abs:=0;
+ sWerte.params.tSiz_:=dateien[i].tMax-dateien[i].tMin+1;
+ sWerte.params.xSteps_:=dateien[i].xMax-dateien[i].xMin+1;
end
else begin
- dateien[i].t0abs:=
- dateien[i-1].t0abs + dateien[i-1].tsiz;
- sWerte.params.tsiz_:=
- sWerte.params.tsiz_ + dateien[i].tmax-dateien[i].tmin+1;
- if sWerte.params.xsteps_<>dateien[i].xmax-dateien[i].xmin+1 then begin
+ dateien[i].t0Abs:=
+ dateien[i-1].t0Abs + dateien[i-1].tSiz;
+ sWerte.params.tSiz_:=
+ sWerte.params.tSiz_ + dateien[i].tMax-dateien[i].tMin+1;
+ if sWerte.params.xSteps_<>dateien[i].xMax-dateien[i].xMin+1 then begin
gibAus('Die Dateien haben unterschiedliche Anzahlen an x-Werten im ausgewählten Bereich!',3);
exit;
end;
@@ -1699,35 +1700,35 @@ begin
result:=true;
end;
-procedure tWerte.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);
+procedure tWerte.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);
var
i,j: longint;
vits: array[boolean] of tVerzerrInitThread;
b: boolean;
begin
- if mt<=1 then begin
- for i:=0 to _tsiz-1 do
- for j:=0 to _xsteps-1 do
- ZAs[j + i*_xsteps]:=0;
+ if mT<=1 then begin
+ for i:=0 to _tSiz-1 do
+ for j:=0 to _xSteps-1 do
+ zAs[j + i*_xSteps]:=0;
for i:=tMin to tMax do
for j:=xMin to xMax do begin
- ZGs[j+i*quelle._xsteps]:=verzerrung.transformiereKoordinaten(j,i,verzerrAnzahl-1);
- ZPs[j+i*quelle._xsteps]['x']:=floor(ZGs[j+i*quelle._xsteps]['x']);
- ZPs[j+i*quelle._xsteps]['y']:=floor(ZGs[j+i*quelle._xsteps]['y']);
- ZGs[j+i*quelle._xsteps]['x']:=
- ZGs[j+i*quelle._xsteps]['x'] - ZPs[j+i*quelle._xsteps]['x'];
- ZGs[j+i*quelle._xsteps]['y']:=
- ZGs[j+i*quelle._xsteps]['y'] - ZPs[j+i*quelle._xsteps]['y'];
- ZPs[j+i*quelle._xsteps]['x']:=ZPs[j+i*quelle._xsteps]['x'] - x0Abs; // Zielpositionen um die Nullposition verschieben
- ZPs[j+i*quelle._xsteps]['y']:=ZPs[j+i*quelle._xsteps]['y'] - t0Abs;
- ZAs[ZPs[j+i*quelle._xsteps]['x'] + ZPs[j+i*quelle._xsteps]['y']*_xsteps]:=
- ZAs[ZPs[j+i*quelle._xsteps]['x'] + ZPs[j+i*quelle._xsteps]['y']*_xsteps] + (1-ZGs[j+i*quelle._xsteps]['x'])*(1-ZGs[j+i*quelle._xsteps]['y']);
- ZAs[ZPs[j+i*quelle._xsteps]['x'] + 1 + ZPs[j+i*quelle._xsteps]['y']*_xsteps]:=
- ZAs[ZPs[j+i*quelle._xsteps]['x'] + 1 + ZPs[j+i*quelle._xsteps]['y']*_xsteps] + ZGs[j+i*quelle._xsteps]['x']*(1-ZGs[j+i*quelle._xsteps]['y']);
- ZAs[ZPs[j+i*quelle._xsteps]['x'] + (ZPs[j+i*quelle._xsteps]['y'] + 1)*_xsteps]:=
- ZAs[ZPs[j+i*quelle._xsteps]['x'] + (ZPs[j+i*quelle._xsteps]['y'] + 1)*_xsteps] + (1-ZGs[j+i*quelle._xsteps]['x'])*ZGs[j+i*quelle._xsteps]['y'];
- ZAs[ZPs[j+i*quelle._xsteps]['x'] + 1 + (ZPs[j+i*quelle._xsteps]['y'] + 1)*_xsteps]:=
- ZAs[ZPs[j+i*quelle._xsteps]['x'] + 1 + (ZPs[j+i*quelle._xsteps]['y'] + 1)*_xsteps] + ZGs[j+i*quelle._xsteps]['x']*ZGs[j+i*quelle._xsteps]['y'];
+ zGs[j+i*quelle._xSteps]:=verzerrung.transformiereKoordinaten(j,i,verzerrAnzahl-1);
+ zPs[j+i*quelle._xSteps]['x']:=floor(zGs[j+i*quelle._xSteps]['x']);
+ zPs[j+i*quelle._xSteps]['y']:=floor(zGs[j+i*quelle._xSteps]['y']);
+ zGs[j+i*quelle._xSteps]['x']:=
+ zGs[j+i*quelle._xSteps]['x'] - zPs[j+i*quelle._xSteps]['x'];
+ zGs[j+i*quelle._xSteps]['y']:=
+ zGs[j+i*quelle._xSteps]['y'] - zPs[j+i*quelle._xSteps]['y'];
+ zPs[j+i*quelle._xSteps]['x']:=zPs[j+i*quelle._xSteps]['x'] - x0Abs; // Zielpositionen um die Nullposition verschieben
+ zPs[j+i*quelle._xSteps]['y']:=zPs[j+i*quelle._xSteps]['y'] - t0Abs;
+ zAs[zPs[j+i*quelle._xSteps]['x'] + zPs[j+i*quelle._xSteps]['y']*_xSteps]:=
+ zAs[zPs[j+i*quelle._xSteps]['x'] + zPs[j+i*quelle._xSteps]['y']*_xSteps] + (1-zGs[j+i*quelle._xSteps]['x'])*(1-zGs[j+i*quelle._xSteps]['y']);
+ zAs[zPs[j+i*quelle._xSteps]['x'] + 1 + zPs[j+i*quelle._xSteps]['y']*_xSteps]:=
+ zAs[zPs[j+i*quelle._xSteps]['x'] + 1 + zPs[j+i*quelle._xSteps]['y']*_xSteps] + zGs[j+i*quelle._xSteps]['x']*(1-zGs[j+i*quelle._xSteps]['y']);
+ zAs[zPs[j+i*quelle._xSteps]['x'] + (zPs[j+i*quelle._xSteps]['y'] + 1)*_xSteps]:=
+ zAs[zPs[j+i*quelle._xSteps]['x'] + (zPs[j+i*quelle._xSteps]['y'] + 1)*_xSteps] + (1-zGs[j+i*quelle._xSteps]['x'])*zGs[j+i*quelle._xSteps]['y'];
+ zAs[zPs[j+i*quelle._xSteps]['x'] + 1 + (zPs[j+i*quelle._xSteps]['y'] + 1)*_xSteps]:=
+ zAs[zPs[j+i*quelle._xSteps]['x'] + 1 + (zPs[j+i*quelle._xSteps]['y'] + 1)*_xSteps] + zGs[j+i*quelle._xSteps]['x']*zGs[j+i*quelle._xSteps]['y'];
end;
end
else begin
@@ -1742,58 +1743,58 @@ begin
tMax,
x0Abs,
t0Abs,
- mt div 2 + byte(odd(mt) and b),
+ mT div 2 + byte(odd(mT) and b),
epsilon,
verzerrung,
verzerrAnzahl,
- ZPs,
- ZGs,
+ zPs,
+ zGs,
Warn);
while not (vits[false].fertig and vits[true].fertig) do
sleep(10);
- for i:=0 to length(ZAs)-1 do
- ZAs[i]:=
- vits[false].ZAs[i] +
- vits[true].ZAs[i];
+ for i:=0 to length(zAs)-1 do
+ zAs[i]:=
+ vits[false].zAs[i] +
+ vits[true].zAs[i];
for b:=false to true do
vits[b].free;
end;
if oberst then
- for i:=0 to length(ZAs)-1 do
- if ZAs[i]<epsilon then begin
+ for i:=0 to length(zAs)-1 do
+ if zAs[i]<epsilon then begin
if Warn=wsStreng then
- gibAus('Warnung: Erhöhe Divisor ['+inttostr(i)+':'+inttostr(i mod _xsteps)+','+inttostr(i div _xsteps)+'] von '+floattostr(ZAs[i])+' auf epsilon='+floattostr(epsilon)+'.',1);
- ZAs[i]:=epsilon;
+ gibAus('Warnung: Erhöhe Divisor ['+intToStr(i)+':'+intToStr(i mod _xSteps)+','+intToStr(i div _xSteps)+'] von '+floatToStr(zAs[i])+' auf epsilon='+floatToStr(epsilon)+'.',1);
+ zAs[i]:=epsilon;
end;
end;
-function tWerte.xscale: extended;
+function tWerte.xScale: extended;
begin
- if Transformationen.xstop=Transformationen.xstart then result:=1
- else result:=(Transformationen.xstop-Transformationen.xstart)/(Transformationen.xsteps-1);
+ if transformationen.xStop=transformationen.xStart then result:=1
+ else result:=(transformationen.xStop-transformationen.xStart)/(transformationen.xSteps-1);
end;
-function tWerte.tscale: extended;
+function tWerte.tScale: extended;
begin
- if Transformationen.tstop=Transformationen.tstart then result:=1
- else result:=(Transformationen.tstop-Transformationen.tstart)/(Transformationen.tsiz-1);
+ if transformationen.tStop=transformationen.tStart then result:=1
+ else result:=(transformationen.tStop-transformationen.tStart)/(transformationen.tSiz-1);
end;
-function tWerte.dichtenParameterErkannt(st: boolean; s: string; var bekannteBefehle: tMyStringList; threads,xmin,xmax,tmin,tmax: longint): boolean;
+function tWerte.dichtenParameterErkannt(sT: boolean; s: string; var bekannteBefehle: tMyStringList; threads,xMin,xMax,tMin,tMax: longint): boolean;
begin
result:=true;
bekannteBefehle.add('''maximale und minimale Dichten bestimmen''');
bekannteBefehle.add('''maximale und minimale Dichten bestimmen (symmetrisch)''');
if startetMit('maximale und minimale Dichten bestimmen',s) then begin
- ermittleMinMaxDichten(st,threads,xmin,xmax,tmin,tmax,s='(symmetrisch)');
+ ermittleMinMaxDichten(sT,threads,xMin,xMax,tMin,tMax,s='(symmetrisch)');
exit;
end;
if istDasBefehl('Minimaldichte:',s,bekannteBefehle,true) then begin
- _minW:=exprtofloat(st,s);
+ _minW:=exprToFloat(sT,s);
exit;
end;
if istDasBefehl('Maximaldichte:',s,bekannteBefehle,true) then begin
- _maxW:=exprtofloat(st,s);
+ _maxW:=exprToFloat(sT,s);
exit;
end;
result:=false;
@@ -1808,9 +1809,9 @@ function tWerte.kont2disk(dir: char; x: extended): longint;
begin
case dir of
'x':
- result:=min(_xsteps-1,max(0,round(kont2diskFak(dir,x-Transformationen.xstart))));
+ result:=min(_xSteps-1,max(0,round(kont2diskFak(dir,x-transformationen.xStart))));
'y','t':
- result:=min(_tsiz-1,max(0,round(kont2diskFak(dir,x-Transformationen.tstart))));
+ result:=min(_tSiz-1,max(0,round(kont2diskFak(dir,x-transformationen.tStart))));
else
result:=-1;
end;
@@ -1825,9 +1826,9 @@ function tWerte.kont2diskFak(dir: char; x: extended): extended;
begin
case dir of
'x':
- result:=x*(_xsteps-1)/(Transformationen.xstop-Transformationen.xstart);
+ result:=x*(_xSteps-1)/(transformationen.xStop-transformationen.xStart);
'y','t':
- result:=x*(_tsiz-1)/(Transformationen.tstop-Transformationen.tstart);
+ result:=x*(_tSiz-1)/(transformationen.tStop-transformationen.tStart);
else
result:=-1;
end;
@@ -1837,9 +1838,9 @@ function tWerte.disk2kont(dir: char; x: longint): extended;
begin
case dir of
'x':
- result:=disk2kontFak(dir,x)+Transformationen.xstart;
+ result:=disk2kontFak(dir,x)+transformationen.xStart;
'y','t':
- result:=disk2kontFak(dir,x)+Transformationen.tstart;
+ result:=disk2kontFak(dir,x)+transformationen.tStart;
else
result:=nan;
end;
@@ -1854,9 +1855,9 @@ function tWerte.disk2kontFak(dir: char; x: longint): extended;
begin
case dir of
'x':
- result:=x/(_xsteps-1)*(Transformationen.xstop-Transformationen.xstart);
+ result:=x/(_xSteps-1)*(transformationen.xStop-transformationen.xStart);
'y','t':
- result:=x/(_tsiz-1)*(Transformationen.tstop-Transformationen.tstart);
+ result:=x/(_tSiz-1)*(transformationen.tStop-transformationen.tStart);
else
result:=nan;
end;
@@ -1864,7 +1865,7 @@ end;
procedure tWerte.schreibeWertIntegriert(var f: textfile; i: longint; hor: boolean);
begin
- case Genauigkeit of
+ case genauigkeit of
gSingle:
sWerte.schreibeWertIntegriert(f,i,hor);
gDouble:
@@ -1874,7 +1875,19 @@ begin
end{of case};
end;
-function tWerte.ladeDateien(st: boolean; f: tMyStringlist; pl,sa: boolean): boolean;
+procedure tWerte.holeRAM(ausgaben: byte);
+begin
+ case genauigkeit of
+ gSingle:
+ sWerte.holeRAM(ausgaben);
+ gDouble:
+ dWerte.holeRAM(ausgaben);
+ gExtended:
+ eWerte.holeRAM(ausgaben);
+ end{of case};
+end;
+
+function tWerte.ladeDateien(sT: boolean; f: tMyStringList; pl,sA: boolean): boolean;
var
inputs: tGenerischeInputDateiInfoArray;
@@ -1885,14 +1898,14 @@ begin
for ii:=0 to length(inputs)-1 do
if assigned(inputs[ii]) then
inputs[ii].free;
- setlength(inputs,0);
+ setLength(inputs,0);
end;
begin
result:=false;
- warteaufBeendigungDesLeseThreads;
- Transformationen:=tKeineTransformation.create;
- Genauigkeit:=gSingle;
+ warteAufBeendigungDesLeseThreads;
+ transformationen:=tKeineTransformation.create;
+ genauigkeit:=gSingle;
if not ermittleExterneInputParameter(f,inputs) then begin
aufraeumen;
exit;
@@ -1901,21 +1914,14 @@ begin
aufraeumen;
exit;
end;
- if not st then begin
- case Genauigkeit of
- gSingle:
- sWerte.holeRam(3*byte(sa));
- gDouble:
- dWerte.holeRam(3*byte(sa));
- gExtended:
- eWerte.holeRam(3*byte(sa));
- end{of case};
+ if not sT then begin
+ holeRAM(3*byte(sA));
if pl then begin
leseThread:=tLeseThread.create(self,inputs);
result:=true;
end
else
- case Genauigkeit of
+ case genauigkeit of
gSingle:
result:=sWerte.liesDateien(inputs);
gDouble:
@@ -1926,11 +1932,11 @@ begin
end
else
result:=true;
- Transformationen.xsteps:=_xsteps;
- Transformationen.tsiz:=_tsiz;
+ transformationen.xSteps:=_xSteps;
+ transformationen.tSiz:=_tSiz;
end;
-function tWerte.ladeAscii(st: boolean; datei: string): boolean;
+function tWerte.ladeAscii(sT: boolean; datei: string): boolean;
var
i,j,k: integer;
Zeit: extended;
@@ -1938,17 +1944,17 @@ var
s,t: string;
begin
result:=false;
- warteaufBeendigungDesLeseThreads;
- Genauigkeit:=gExtended;
- _tsiz:=-100;
+ warteAufBeendigungDesLeseThreads;
+ genauigkeit:=gExtended;
+ _tSiz:=-100;
- Transformationen:=tKeineTransformation.create;
+ transformationen:=tKeineTransformation.create;
- Transformationen.tstart:=-100;
- Transformationen.tstop:=-100;
- _xsteps:=-100;
- Transformationen.xstart:=-100;
- Transformationen.xstop:=-100;
+ transformationen.tStart:=-100;
+ transformationen.tStop:=-100;
+ _xSteps:=-100;
+ transformationen.xStart:=-100;
+ transformationen.xStop:=-100;
_np:=-100;
_beta:=-100;
assignFile(g,datei);
@@ -1958,56 +1964,56 @@ begin
s:=erstesArgument(s,'#');
if s='' then continue;
if s='Header Ende' then break;
- if startetMit('tsiz',s) then begin
- _tsiz:=strtoint(s);
+ if startetMit('tSiz',s) then begin
+ _tSiz:=strtoint(s);
continue;
end;
- if startetMit('tstart',s) then begin
- Transformationen.tstart:=exprtofloat(st,s);
+ if startetMit('tStart',s) then begin
+ transformationen.tStart:=exprToFloat(sT,s);
continue;
end;
- if startetMit('tstop',s) then begin
- Transformationen.tstop:=exprtofloat(st,s);
+ if startetMit('tStop',s) then begin
+ transformationen.tStop:=exprToFloat(sT,s);
continue;
end;
- if startetMit('xsteps',s) then begin
- _xsteps:=strtoint(s);
+ if startetMit('xSteps',s) then begin
+ _xSteps:=strtoint(s);
continue;
end;
- if startetMit('xstart',s) then begin
- Transformationen.xstart:=exprtofloat(st,s);
+ if startetMit('xStart',s) then begin
+ transformationen.xStart:=exprToFloat(sT,s);
continue;
end;
- if startetMit('xstop',s) then begin
- Transformationen.xstop:=exprtofloat(st,s);
+ if startetMit('xStop',s) then begin
+ transformationen.xStop:=exprToFloat(sT,s);
continue;
end;
if startetMit('np',s) then begin
- _np:=exprtofloat(st,s);
+ _np:=exprToFloat(sT,s);
continue;
end;
if startetMit('beta',s) then begin
- _beta:=exprtofloat(st,s);
+ _beta:=exprToFloat(sT,s);
continue;
end;
gibAus('Verstehe Option '''+s+''' in Asci-Input-Datei '''+datei+''' nicht!',3);
- closefile(g);
+ closeFile(g);
exit;
end;
- if (_tsiz=-100) or
- (Transformationen.tstart=-100) or
- (Transformationen.tstop=-100) or
- (_xsteps=-100) or
- (Transformationen.xstart=-100) or
- (Transformationen.xstop=-100) or
+ if (_tSiz=-100) or
+ (transformationen.tStart=-100) or
+ (transformationen.tStop=-100) or
+ (_xSteps=-100) or
+ (transformationen.xStart=-100) or
+ (transformationen.xStop=-100) or
(_np=-100) or
(_beta=-100) then begin
gibAus('Ungenügende Informationen über Raumzeitfenster in Asci-Input-Datei '''+datei+'''!',3);
- closefile(g);
+ closeFile(g);
exit;
end;
- if not st then begin
- eWerte.holeRam(3);
+ if not sT then begin
+ holeRAM(3);
gibAus('Datei einlesen ...',3);
end;
Zeit:=now;
@@ -2016,7 +2022,7 @@ begin
repeat
if eof(g) then begin
gibAus('Unerwartetes Dateiende in Asci-Input-Datei '''+datei+'''!',3);
- closefile(g);
+ closeFile(g);
exit;
end;
readln(g,t);
@@ -2029,41 +2035,41 @@ begin
until (i=0) and (length(s)>0);
if not eof(g) then begin
gibAus('Zu viele Zeilen in Asci-Input-Datei '''+datei+'''!',3);
- closefile(g);
+ closeFile(g);
exit;
end;
- closefile(g);
+ closeFile(g);
k:=1;
while s[k]<>'{' do inc(k);
inc(k);
- for i:=0 to _tsiz-1 do begin
+ for i:=0 to _tSiz-1 do begin
while s[k]<>'{' do inc(k);
- for j:=0 to _xsteps-1 do begin
+ for j:=0 to _xSteps-1 do begin
t:='';
while not (s[k] in [',','}']) do begin
if s[k] in ['-','0'..'9','e','E','.'] then t:=t+s[k];
if s[k] = '^' then t:=t+'E';
inc(k);
end;
- if (s[k]='}') xor (j=_xsteps-1) then begin
- gibAus('Falsche Anzahl an Datenspalten in Asci-Input-Datei '''+datei+''' in Datenzeile '+inttostr(i+1)+'!',3);
+ if (s[k]='}') xor (j=_xSteps-1) then begin
+ gibAus('Falsche Anzahl an Datenspalten in Asci-Input-Datei '''+datei+''' in Datenzeile '+intToStr(i+1)+'!',3);
exit;
end;
if (pos(',',t)>0) and (pos('e',t)=0) and (pos('E',t)=0) then t:=t+'0';
- if not st then
- eWerte.werte[j+i*_tsiz]:=strtofloat(t);
+ if not sT then
+ eWerte.werte[j+i*_tSiz]:=strToFloat(t);
inc(k);
end;
end;
- Transformationen.xsteps:=_xsteps;
- Transformationen.tsiz:=_tsiz;
+ transformationen.xSteps:=_xSteps;
+ transformationen.tSiz:=_tSiz;
gibAus('... fertig '+timetostr(now-Zeit),3);
result:=true;
end;
-function tWerte.berechneLiKo(st: boolean; f: tMyStringlist; threads: longint): boolean;
+function tWerte.berechneLiKo(sT: boolean; f: tMyStringList; threads: longint): boolean;
var
- i,xmin,xmax,tmin,tmax: longint;
+ i,xMin,xMax,tMin,tMax: longint;
liKo: tLiKo;
s: string;
fertig: boolean;
@@ -2071,11 +2077,11 @@ var
Zeit: extended;
begin
result:=false;
- warteaufBeendigungDesLeseThreads;
- setlength(liKo,0);
- Genauigkeit:=gExtended;
- _xsteps:=0;
- _tsiz:=0;
+ warteAufBeendigungDesLeseThreads;
+ setLength(liKo,0);
+ genauigkeit:=gExtended;
+ _xSteps:=0;
+ _tSiz:=0;
Zeit:=now;
repeat
if not f.metaReadln(s,true) then begin
@@ -2083,94 +2089,94 @@ begin
exit;
end;
if s='Ende' then break;
- if startetMit('xmin:',s) then begin
+ if startetMit('xMin:',s) then begin
if length(liKo)=0 then begin
- gibAus('xmin kann erst gesetzt werden, wenn wenigstens eine Komponente bekannt ist',3);
+ gibAus('xMin kann erst gesetzt werden, wenn wenigstens eine Komponente bekannt ist',3);
exit;
end;
- xmin:=liKo[0].werte.kont2disk('x',exprtofloat(st,s));
+ xMin:=liKo[0].werte.kont2disk('x',exprToFloat(sT,s));
continue;
end;
- if startetMit('xmax:',s) then begin
+ if startetMit('xMax:',s) then begin
if length(liKo)=0 then begin
- gibAus('xmax kann erst gesetzt werden, wenn wenigstens eine Komponente bekannt ist',3);
+ gibAus('xMax kann erst gesetzt werden, wenn wenigstens eine Komponente bekannt ist',3);
exit;
end;
- xmax:=liKo[0].werte.kont2disk('x',exprtofloat(st,s));
+ xMax:=liKo[0].werte.kont2disk('x',exprToFloat(sT,s));
continue;
end;
- if startetMit('tmin:',s) then begin
+ if startetMit('tMin:',s) then begin
if length(liKo)=0 then begin
- gibAus('tmin kann erst gesetzt werden, wenn wenigstens eine Komponente bekannt ist',3);
+ gibAus('tMin kann erst gesetzt werden, wenn wenigstens eine Komponente bekannt ist',3);
exit;
end;
- tmin:=liKo[0].werte.kont2disk('t',exprtofloat(st,s));
+ tMin:=liKo[0].werte.kont2disk('t',exprToFloat(sT,s));
continue;
end;
- if startetMit('tmax:',s) then begin
+ if startetMit('tMax:',s) then begin
if length(liKo)=0 then begin
- gibAus('tmax kann erst gesetzt werden, wenn wenigstens eine Komponente bekannt ist',3);
+ gibAus('tMax kann erst gesetzt werden, wenn wenigstens eine Komponente bekannt ist',3);
exit;
end;
- tmax:=liKo[0].werte.kont2disk('t',exprtofloat(st,s));
+ tMax:=liKo[0].werte.kont2disk('t',exprToFloat(sT,s));
continue;
end;
if (s='in t auf Zweierpotenz kürzen') or (s='in y auf Zweierpotenz kürzen') then begin
- i:=round(power(2,floor(ln(tmax-tmin+1)/ln(2))));
- tmax:=(tmax+tmin+i) div 2;
- tmin:=tmax-i+1;
+ i:=round(power(2,floor(ln(tMax-tMin+1)/ln(2))));
+ tMax:=(tMax+tMin+i) div 2;
+ tMin:=tMax-i+1;
continue;
end;
if s='in x auf Zweierpotenz kürzen' then begin
- i:=round(power(2,floor(ln(xmax-xmin+1)/ln(2))));
- xmax:=(xmax+xmin+i) div 2;
- xmin:=xmax-i+1;
+ i:=round(power(2,floor(ln(xMax-xMin+1)/ln(2))));
+ xMax:=(xMax+xMin+i) div 2;
+ xMin:=xMax-i+1;
continue;
end;
- setlength(liKo,length(liKo)+1);
- i:=findeWerte(erstesArgument(s),nil,wertes,Konturen,false);
+ setLength(liKo,length(liKo)+1);
+ i:=findeWerte(erstesArgument(s),nil,wertes,konturen,false);
if i<0 then
exit;
- liKo[length(liKo)-1].alpha:=wertes^[i].exprtofloat(st,s);
+ liKo[length(liKo)-1].alpha:=wertes^[i].exprToFloat(sT,s);
while i<0 do i:=i+length(wertes^)-1;
liKo[length(liKo)-1].werte:=wertes^[i mod (length(wertes^)-1)];
- if _xsteps=0 then begin
- _xsteps:=liKo[length(liKo)-1].werte._xsteps;
- xmin:=0;
- xmax:=_xsteps-1;
- end;
- if _tsiz=0 then begin
- _tsiz:=liKo[length(liKo)-1].werte._tsiz;
- tmin:=0;
- tmax:=_tsiz-1;
- end;
- if _xsteps<>liKo[length(liKo)-1].werte._xsteps then begin
- gibAus('Unterschiedliche Anzahl an x-Schritten: '+inttostr(_xsteps)+' bisher vs. '+inttostr(liKo[length(liKo)-1].werte._xsteps)+' bei '+inttostr(i)+'!',3);
+ if _xSteps=0 then begin
+ _xSteps:=liKo[length(liKo)-1].werte._xSteps;
+ xMin:=0;
+ xMax:=_xSteps-1;
+ end;
+ if _tSiz=0 then begin
+ _tSiz:=liKo[length(liKo)-1].werte._tSiz;
+ tMin:=0;
+ tMax:=_tSiz-1;
+ end;
+ if _xSteps<>liKo[length(liKo)-1].werte._xSteps then begin
+ gibAus('Unterschiedliche Anzahl an x-Schritten: '+intToStr(_xSteps)+' bisher vs. '+intToStr(liKo[length(liKo)-1].werte._xSteps)+' bei '+intToStr(i)+'!',3);
exit;
end;
- if _tsiz<>liKo[length(liKo)-1].werte._tsiz then begin
- gibAus('Unterschiedliche Anzahl an t-Schritten: '+inttostr(_tsiz)+' bisher vs. '+inttostr(liKo[length(liKo)-1].werte._tsiz)+' bei '+inttostr(i)+'!',3);
+ if _tSiz<>liKo[length(liKo)-1].werte._tSiz then begin
+ gibAus('Unterschiedliche Anzahl an t-Schritten: '+intToStr(_tSiz)+' bisher vs. '+intToStr(liKo[length(liKo)-1].werte._tSiz)+' bei '+intToStr(i)+'!',3);
exit;
end;
- if liKo[length(liKo)-1].werte.Genauigkeit<>liKo[0].werte.Genauigkeit then begin
+ if liKo[length(liKo)-1].werte.genauigkeit<>liKo[0].werte.genauigkeit then begin
gibAus('Ich bin dumm, ich kann nur Werte mit gleicher Genauigkeit zusammenrechnen!',3);
exit;
end;
- if liKo[length(liKo)-1].werte.Transformationen.xstart<>liKo[0].werte.Transformationen.xstart then begin
- gibAus('Anfangspostionen passen nicht zusammen ('+floattostr(liKo[0].werte.Transformationen.xstart)+' bisher vs. '+floattostr(liKo[length(liKo)-1].werte.Transformationen.xstart)+' bei '+inttostr(i)+')!',3);
+ if liKo[length(liKo)-1].werte.transformationen.xStart<>liKo[0].werte.transformationen.xStart then begin
+ gibAus('Anfangspostionen passen nicht zusammen ('+floatToStr(liKo[0].werte.transformationen.xStart)+' bisher vs. '+floatToStr(liKo[length(liKo)-1].werte.transformationen.xStart)+' bei '+intToStr(i)+')!',3);
exit;
end;
- if liKo[length(liKo)-1].werte.Transformationen.xstop<>liKo[0].werte.Transformationen.xstop then begin
- gibAus('Endpostionen passen nicht zusammen ('+floattostr(liKo[0].werte.Transformationen.xstop)+' bisher vs. '+floattostr(liKo[length(liKo)-1].werte.Transformationen.xstop)+' bei '+inttostr(i)+')!',3);
+ if liKo[length(liKo)-1].werte.transformationen.xStop<>liKo[0].werte.transformationen.xStop then begin
+ gibAus('Endpostionen passen nicht zusammen ('+floatToStr(liKo[0].werte.transformationen.xStop)+' bisher vs. '+floatToStr(liKo[length(liKo)-1].werte.transformationen.xStop)+' bei '+intToStr(i)+')!',3);
exit;
end;
- if liKo[length(liKo)-1].werte.Transformationen.tstart<>liKo[0].werte.Transformationen.tstart then begin
- gibAus('Anfangszeiten passen nicht zusammen ('+floattostr(liKo[0].werte.Transformationen.tstart)+' bisher vs. '+floattostr(liKo[length(liKo)-1].werte.Transformationen.tstart)+' bei '+inttostr(i)+')!',3);
+ if liKo[length(liKo)-1].werte.transformationen.tStart<>liKo[0].werte.transformationen.tStart then begin
+ gibAus('Anfangszeiten passen nicht zusammen ('+floatToStr(liKo[0].werte.transformationen.tStart)+' bisher vs. '+floatToStr(liKo[length(liKo)-1].werte.transformationen.tStart)+' bei '+intToStr(i)+')!',3);
exit;
end;
- if liKo[length(liKo)-1].werte.Transformationen.tstop<>liKo[0].werte.Transformationen.tstop then begin
- gibAus('Endzeiten passen nicht zusammen ('+floattostr(liKo[0].werte.Transformationen.tstop)+' bisher vs. '+floattostr(liKo[length(liKo)-1].werte.Transformationen.tstop)+' bei '+inttostr(i)+')!',3);
+ if liKo[length(liKo)-1].werte.transformationen.tStop<>liKo[0].werte.transformationen.tStop then begin
+ gibAus('Endzeiten passen nicht zusammen ('+floatToStr(liKo[0].werte.transformationen.tStop)+' bisher vs. '+floatToStr(liKo[length(liKo)-1].werte.transformationen.tStop)+' bei '+intToStr(i)+')!',3);
exit;
end;
until false;
@@ -2179,24 +2185,24 @@ begin
gibAus('Leere Linearkombination!',3);
exit;
end;
- _xsteps:=xmax-xmin+1;
- _tsiz:=tmax-tmin+1;
- Transformationen:=tUeberlagerung.create;
+ _xSteps:=xMax-xMin+1;
+ _tSiz:=tMax-tMin+1;
+ transformationen:=tUeberlagerung.create;
for i:=0 to length(liKo)-1 do
- (Transformationen as tUeberlagerung).addKomponente(liKo[i].werte.Transformationen);
- Transformationen:=tKoordinatenAusschnitt.create(Transformationen,xmin,xmax,tmin,tmax);
+ (transformationen as tUeberlagerung).addKomponente(liKo[i].werte.transformationen);
+ transformationen:=tKoordinatenAusschnitt.create(transformationen,xMin,xMax,tMin,tMax);
_np:=liKo[0].werte._np;
_beta:=liKo[0].werte._beta;
- if st then begin
+ if sT then begin
result:=true;
exit;
end;
- eWerte.holeRam(3);
+ holeRAM(3);
gibAus('Berechne ...',3);
Zeit:=now;
- setlength(liKoThreads,threads);
+ setLength(liKoThreads,threads);
for i:=0 to length(liKoThreads)-1 do
- liKoThreads[i]:=tLiKoThread.create(@liKo,self,round(i*_xsteps/threads),round((i+1)*_xsteps/threads-1),0,_tsiz-1,xmin,tmin);
+ liKoThreads[i]:=tLiKoThread.create(@liKo,self,round(i*_xSteps/threads),round((i+1)*_xSteps/threads-1),0,_tSiz-1,xMin,tMin);
repeat
sleep(10);
fertig:=true;
@@ -2209,97 +2215,97 @@ begin
result:=true;
end;
-function tWerte.berechneAgglomeration(st: boolean; var f: tMyStringlist): boolean;
+function tWerte.berechneAgglomeration(sT: boolean; var f: tMyStringList): boolean;
var
- i,xmin,xmax,tmin,tmax: longint;
+ i,xMin,xMax,tMin,tMax: longint;
quellen: tWerteArray;
s: string;
Zeit: extended;
begin
result:=false;
- warteaufBeendigungDesLeseThreads;
- setlength(quellen,0);
- Genauigkeit:=gExtended;
- _xsteps:=0;
- _tsiz:=0;
- xmin:=-1;
- xmax:=-1;
- tmin:=-1;
- tmax:=-1;
+ warteAufBeendigungDesLeseThreads;
+ setLength(quellen,0);
+ genauigkeit:=gExtended;
+ _xSteps:=0;
+ _tSiz:=0;
+ xMin:=-1;
+ xMax:=-1;
+ tMin:=-1;
+ tMax:=-1;
Zeit:=now;
- Transformationen:=tAgglomeration.create;
- (Transformationen as tAgglomeration).schritt:=-1;
- (Transformationen as tAgglomeration).horizontal:=false;
+ transformationen:=tAgglomeration.create;
+ (transformationen as tAgglomeration).schritt:=-1;
+ (transformationen as tAgglomeration).horizontal:=false;
repeat
if not f.metaReadln(s,true) then begin
gibAus('Unerwartetes Dateiende!',3);
exit;
end;
if s='Ende' then break;
- if startetMit('xmin:',s) then begin
- xmin:=quellen[0].kont2disk('x',exprtofloat(st,s));
+ if startetMit('xMin:',s) then begin
+ xMin:=quellen[0].kont2disk('x',exprToFloat(sT,s));
continue;
end;
- if startetMit('xmax:',s) then begin
- xmax:=quellen[0].kont2disk('x',exprtofloat(st,s));
+ if startetMit('xMax:',s) then begin
+ xMax:=quellen[0].kont2disk('x',exprToFloat(sT,s));
continue;
end;
- if startetMit('tmin:',s) then begin
- tmin:=quellen[0].kont2disk('t',exprtofloat(st,s));
+ if startetMit('tMin:',s) then begin
+ tMin:=quellen[0].kont2disk('t',exprToFloat(sT,s));
continue;
end;
- if startetMit('tmax:',s) then begin
- tmax:=quellen[0].kont2disk('t',exprtofloat(st,s));
+ if startetMit('tMax:',s) then begin
+ tMax:=quellen[0].kont2disk('t',exprToFloat(sT,s));
continue;
end;
if startetMit('Schritt:',s) then begin
- (Transformationen as tAgglomeration).schritt:=exprtofloat(st,s);
+ (transformationen as tAgglomeration).schritt:=exprToFloat(sT,s);
continue;
end;
if startetMit('Nullposition:',s) then begin
- (Transformationen as tAgglomeration).nullposition:=exprtofloat(st,s);
+ (transformationen as tAgglomeration).nullposition:=exprToFloat(sT,s);
continue;
end;
if s='waagerecht' then begin
- (Transformationen as tAgglomeration).horizontal:=true;
+ (transformationen as tAgglomeration).horizontal:=true;
continue;
end;
if s='senkrecht' then begin
- (Transformationen as tAgglomeration).horizontal:=true;
+ (transformationen as tAgglomeration).horizontal:=true;
continue;
end;
- setlength(quellen,length(quellen)+1);
- i:=findeWerte(erstesArgument(s),nil,wertes,Konturen,false);
+ setLength(quellen,length(quellen)+1);
+ i:=findeWerte(erstesArgument(s),nil,wertes,konturen,false);
if (i<0) or (wertes^[i]=self) then
exit;
quellen[length(quellen)-1]:=wertes^[i];
if length(quellen)=1 then begin
- _xsteps:=quellen[0]._xsteps;
- _tsiz:=quellen[0]._tsiz;
+ _xSteps:=quellen[0]._xSteps;
+ _tSiz:=quellen[0]._tSiz;
end;
- if _xsteps<>quellen[length(quellen)-1]._xsteps then begin
- gibAus('Unterschiedliche Anzahl an x-Schritten: '+inttostr(_xsteps)+' bisher vs. '+inttostr(quellen[length(quellen)-1]._xsteps)+' bei '+inttostr(i)+'!',3);
+ if _xSteps<>quellen[length(quellen)-1]._xSteps then begin
+ gibAus('Unterschiedliche Anzahl an x-Schritten: '+intToStr(_xSteps)+' bisher vs. '+intToStr(quellen[length(quellen)-1]._xSteps)+' bei '+intToStr(i)+'!',3);
exit;
end;
- if _tsiz<>quellen[length(quellen)-1]._tsiz then begin
- gibAus('Unterschiedliche Anzahl an t-Schritten: '+inttostr(_tsiz)+' bisher vs. '+inttostr(quellen[length(quellen)-1]._tsiz)+' bei '+inttostr(i)+'!',3);
+ if _tSiz<>quellen[length(quellen)-1]._tSiz then begin
+ gibAus('Unterschiedliche Anzahl an t-Schritten: '+intToStr(_tSiz)+' bisher vs. '+intToStr(quellen[length(quellen)-1]._tSiz)+' bei '+intToStr(i)+'!',3);
exit;
end;
- if quellen[length(quellen)-1].Transformationen.xstart<>quellen[0].Transformationen.xstart then begin
- gibAus('Anfangspostionen passen nicht zusammen ('+floattostr(quellen[0].Transformationen.xstart)+' bisher vs. '+floattostr(quellen[length(quellen)-1].Transformationen.xstart)+' bei '+inttostr(i)+')!',3);
+ if quellen[length(quellen)-1].transformationen.xStart<>quellen[0].transformationen.xStart then begin
+ gibAus('Anfangspostionen passen nicht zusammen ('+floatToStr(quellen[0].transformationen.xStart)+' bisher vs. '+floatToStr(quellen[length(quellen)-1].transformationen.xStart)+' bei '+intToStr(i)+')!',3);
exit;
end;
- if quellen[length(quellen)-1].Transformationen.xstop<>quellen[0].Transformationen.xstop then begin
- gibAus('Endpostionen passen nicht zusammen ('+floattostr(quellen[0].Transformationen.xstop)+' bisher vs. '+floattostr(quellen[length(quellen)-1].Transformationen.xstop)+' bei '+inttostr(i)+')!',3);
+ if quellen[length(quellen)-1].transformationen.xStop<>quellen[0].transformationen.xStop then begin
+ gibAus('Endpostionen passen nicht zusammen ('+floatToStr(quellen[0].transformationen.xStop)+' bisher vs. '+floatToStr(quellen[length(quellen)-1].transformationen.xStop)+' bei '+intToStr(i)+')!',3);
exit;
end;
- if quellen[length(quellen)-1].Transformationen.tstart<>quellen[0].Transformationen.tstart then begin
- gibAus('Anfangszeiten passen nicht zusammen ('+floattostr(quellen[0].Transformationen.tstart)+' bisher vs. '+floattostr(quellen[length(quellen)-1].Transformationen.tstart)+' bei '+inttostr(i)+')!',3);
+ if quellen[length(quellen)-1].transformationen.tStart<>quellen[0].transformationen.tStart then begin
+ gibAus('Anfangszeiten passen nicht zusammen ('+floatToStr(quellen[0].transformationen.tStart)+' bisher vs. '+floatToStr(quellen[length(quellen)-1].transformationen.tStart)+' bei '+intToStr(i)+')!',3);
exit;
end;
- if quellen[length(quellen)-1].Transformationen.tstop<>quellen[0].Transformationen.tstop then begin
- gibAus('Endzeiten passen nicht zusammen ('+floattostr(quellen[0].Transformationen.tstop)+' bisher vs. '+floattostr(quellen[length(quellen)-1].Transformationen.tstop)+' bei '+inttostr(i)+')!',3);
+ if quellen[length(quellen)-1].transformationen.tStop<>quellen[0].transformationen.tStop then begin
+ gibAus('Endzeiten passen nicht zusammen ('+floatToStr(quellen[0].transformationen.tStop)+' bisher vs. '+floatToStr(quellen[length(quellen)-1].transformationen.tStop)+' bei '+intToStr(i)+')!',3);
exit;
end;
until false;
@@ -2309,63 +2315,63 @@ begin
exit;
end;
- if xmin<0 then
- xmin:=0;
- if xmax<0 then
- xmax:=quellen[0].Transformationen.xsteps-1;
- if tmin<0 then
- tmin:=0;
- if tmax<0 then
- tmax:=quellen[0].Transformationen.tsiz-1;
+ if xMin<0 then
+ xMin:=0;
+ if xMax<0 then
+ xMax:=quellen[0].transformationen.xSteps-1;
+ if tMin<0 then
+ tMin:=0;
+ if tMax<0 then
+ tMax:=quellen[0].transformationen.tSiz-1;
for i:=0 to length(quellen)-1 do
- (Transformationen as tAgglomeration).addKomponente(
+ (transformationen as tAgglomeration).addKomponente(
tKoordinatenAusschnitt.create(
- quellen[i].Transformationen,
- xmin,xmax,tmin,tmax)
+ quellen[i].transformationen,
+ xMin,xMax,tMin,tMax)
);
- _xsteps:=Transformationen.xsteps;
- _tsiz:=Transformationen.tsiz;
+ _xSteps:=transformationen.xSteps;
+ _tSiz:=transformationen.tSiz;
- _minW:=Transformationen.wmin;
- _maxW:=Transformationen.wmax;
+ _minW:=transformationen.wMin;
+ _maxW:=transformationen.wMax;
_np:=quellen[0]._np;
_beta:=quellen[0]._beta;
- if st then begin
+ if sT then begin
result:=true;
exit;
end;
- eWerte.holeRam(3);
+ holeRAM(3);
gibAus('Berechne ...',3);
Zeit:=now;
for i:=0 to length(quellen)-1 do
- case quellen[i].Genauigkeit of
+ case quellen[i].genauigkeit of
gSingle:
eWerte.kopiereVonNach(
pTLLWerteSingle(@quellen[i].sWerte),
- xmin,xmax,
- tmin,tmax,
- (1+xmax-xmin)*i*byte((Transformationen as tAgglomeration).horizontal),
- (1+tmax-tmin)*i*byte(not (Transformationen as tAgglomeration).horizontal)
+ xMin,xMax,
+ tMin,tMax,
+ (1+xMax-xMin)*i*byte((transformationen as tAgglomeration).horizontal),
+ (1+tMax-tMin)*i*byte(not (transformationen as tAgglomeration).horizontal)
);
gDouble:
eWerte.kopiereVonNach(
pTLLWerteDouble(@quellen[i].dWerte),
- xmin,xmax,
- tmin,tmax,
- (1+xmax-xmin)*i*byte((Transformationen as tAgglomeration).horizontal),
- (1+tmax-tmin)*i*byte(not (Transformationen as tAgglomeration).horizontal)
+ xMin,xMax,
+ tMin,tMax,
+ (1+xMax-xMin)*i*byte((transformationen as tAgglomeration).horizontal),
+ (1+tMax-tMin)*i*byte(not (transformationen as tAgglomeration).horizontal)
);
gExtended:
eWerte.kopiereVonNach(
pTLLWerteExtended(@quellen[i].eWerte),
- xmin,xmax,
- tmin,tmax,
- (1+xmax-xmin)*i*byte((Transformationen as tAgglomeration).horizontal),
- (1+tmax-tmin)*i*byte(not (Transformationen as tAgglomeration).horizontal)
+ xMin,xMax,
+ tMin,tMax,
+ (1+xMax-xMin)*i*byte((transformationen as tAgglomeration).horizontal),
+ (1+tMax-tMin)*i*byte(not (transformationen as tAgglomeration).horizontal)
);
end;
@@ -2373,9 +2379,9 @@ begin
result:=true;
end;
-function tWerte.berechneQuotient(st: boolean; 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;
+ i,xMin,xMax,tMin,tMax: longint;
s: string;
fertig: boolean;
quotientThreads: array of tQuotientThread;
@@ -2383,18 +2389,18 @@ var
bekannteBefehle: tMyStringList;
begin
result:=false;
- warteaufBeendigungDesLeseThreads;
+ warteAufBeendigungDesLeseThreads;
Zeit:=now;
- Transformationen:=tUeberlagerung.create;
- (Transformationen as tUeberlagerung).addKomponente(wertes^[dividend].Transformationen);
- (Transformationen as tUeberlagerung).addKomponente(wertes^[divisor].Transformationen);
- _xsteps:=wertes^[dividend]._xsteps;
- xmin:=0;
- xmax:=_xsteps-1;
- _tsiz:=wertes^[dividend]._tsiz;
- tmin:=0;
- tmax:=_tsiz-1;
+ transformationen:=tUeberlagerung.create;
+ (transformationen as tUeberlagerung).addKomponente(wertes^[dividend].transformationen);
+ (transformationen as tUeberlagerung).addKomponente(wertes^[divisor].transformationen);
+ _xSteps:=wertes^[dividend]._xSteps;
+ xMin:=0;
+ xMax:=_xSteps-1;
+ _tSiz:=wertes^[dividend]._tSiz;
+ tMin:=0;
+ tMax:=_tSiz-1;
_np:=wertes^[dividend]._np;
_beta:=wertes^[dividend]._beta;
epsilon:=1e-9;
@@ -2408,24 +2414,24 @@ begin
end;
bekannteBefehle.clear;
if istDasBefehl('Ende',s,bekannteBefehle,false) then break;
- if istDasBefehl('xmin:',s,bekannteBefehle,true) then begin
- xmin:=kont2disk('x',exprtofloat(st,s));
+ if istDasBefehl('xMin:',s,bekannteBefehle,true) then begin
+ xMin:=kont2disk('x',exprToFloat(sT,s));
continue;
end;
- if istDasBefehl('xmax:',s,bekannteBefehle,true) then begin
- xmax:=kont2disk('x',exprtofloat(st,s));
+ if istDasBefehl('xMax:',s,bekannteBefehle,true) then begin
+ xMax:=kont2disk('x',exprToFloat(sT,s));
continue;
end;
- if istDasBefehl('tmin:',s,bekannteBefehle,true) then begin
- tmin:=kont2disk('t',exprtofloat(st,s));
+ if istDasBefehl('tMin:',s,bekannteBefehle,true) then begin
+ tMin:=kont2disk('t',exprToFloat(sT,s));
continue;
end;
- if istDasBefehl('tmax:',s,bekannteBefehle,true) then begin
- tmax:=kont2disk('t',exprtofloat(st,s));
+ if istDasBefehl('tMax:',s,bekannteBefehle,true) then begin
+ tMax:=kont2disk('t',exprToFloat(sT,s));
continue;
end;
if istDasBefehl('epsilon:',s,bekannteBefehle,true) then begin
- epsilon:=exprtofloat(st,s);
+ epsilon:=exprToFloat(sT,s);
continue;
end;
bekannteBefehle.sort;
@@ -2435,32 +2441,32 @@ begin
until false;
bekannteBefehle.free;
- _xsteps:=xmax-xmin+1;
- _tsiz:=tmax-tmin+1;
- if (wertes^[dividend].Transformationen.xstart<>wertes^[divisor].Transformationen.xstart) or
- (wertes^[dividend].Transformationen.xstop<>wertes^[divisor].Transformationen.xstop) or
- (wertes^[dividend].Transformationen.tstart<>wertes^[divisor].Transformationen.tstart) or
- (wertes^[dividend].Transformationen.tstop<>wertes^[divisor].Transformationen.tstop) or
- (wertes^[dividend]._xsteps<>wertes^[divisor]._xsteps) or
- (wertes^[dividend]._tsiz<>wertes^[divisor]._tsiz) then begin
+ _xSteps:=xMax-xMin+1;
+ _tSiz:=tMax-tMin+1;
+ if (wertes^[dividend].transformationen.xStart<>wertes^[divisor].transformationen.xStart) or
+ (wertes^[dividend].transformationen.xStop<>wertes^[divisor].transformationen.xStop) or
+ (wertes^[dividend].transformationen.tStart<>wertes^[divisor].transformationen.tStart) or
+ (wertes^[dividend].transformationen.tStop<>wertes^[divisor].transformationen.tStop) or
+ (wertes^[dividend]._xSteps<>wertes^[divisor]._xSteps) or
+ (wertes^[dividend]._tSiz<>wertes^[divisor]._tSiz) then begin
// gibAus('Dividend und Divisor haben verschiedene Abmessungen oder verschiedene Genauigkeiten, sowas verstehe ich nicht!',3);
gibAus('Dividend und Divisor haben verschiedene Abmessungen, sowas verstehe ich nicht!',3);
exit;
end;
- Transformationen:=tKoordinatenAusschnitt.create(Transformationen,xmin,xmax,tmin,tmax);
+ transformationen:=tKoordinatenAusschnitt.create(transformationen,xMin,xMax,tMin,tMax);
_np:=wertes^[dividend]._np;
_beta:=wertes^[dividend]._beta;
- Genauigkeit:=gExtended;
- if st then begin
+ genauigkeit:=gExtended;
+ if sT then begin
result:=true;
exit;
end;
- eWerte.holeRam(3);
+ holeRAM(3);
gibAus('Berechne ...',3);
Zeit:=now;
- setlength(quotientThreads,threads);
+ setLength(quotientThreads,threads);
for i:=0 to length(quotientThreads)-1 do
- quotientThreads[i]:=tQuotientThread.create(wertes^[dividend],wertes^[divisor],self,epsilon,round(i*_xsteps/threads),round((i+1)*_xsteps/threads-1),0,_tsiz-1,xmin,tmin);
+ quotientThreads[i]:=tQuotientThread.create(wertes^[dividend],wertes^[divisor],self,epsilon,round(i*_xSteps/threads),round((i+1)*_xSteps/threads-1),0,_tSiz-1,xMin,tMin);
repeat
sleep(10);
fertig:=true;
@@ -2473,9 +2479,9 @@ begin
result:=true;
end;
-function tWerte.berechneProdukt(st: boolean; 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;
+ i,xMin,xMax,tMin,tMax: longint;
s: string;
fertig: boolean;
produktThreads: array of tProduktThread;
@@ -2483,18 +2489,18 @@ var
bekannteBefehle: tMyStringList;
begin
result:=false;
- warteaufBeendigungDesLeseThreads;
+ warteAufBeendigungDesLeseThreads;
Zeit:=now;
- Transformationen:=tUeberlagerung.create;
- (Transformationen as tUeberlagerung).addKomponente(wertes^[faktor1].Transformationen);
- (Transformationen as tUeberlagerung).addKomponente(wertes^[faktor2].Transformationen);
- _xsteps:=Transformationen.xsteps;
- xmin:=0;
- xmax:=_xsteps-1;
- _tsiz:=Transformationen.tsiz;
- tmin:=0;
- tmax:=_tsiz-1;
+ transformationen:=tUeberlagerung.create;
+ (transformationen as tUeberlagerung).addKomponente(wertes^[faktor1].transformationen);
+ (transformationen as tUeberlagerung).addKomponente(wertes^[faktor2].transformationen);
+ _xSteps:=transformationen.xSteps;
+ xMin:=0;
+ xMax:=_xSteps-1;
+ _tSiz:=transformationen.tSiz;
+ tMin:=0;
+ tMax:=_tSiz-1;
_np:=wertes^[faktor1]._np;
_beta:=wertes^[faktor1]._beta;
Zeit:=now;
@@ -2507,20 +2513,20 @@ begin
end;
bekannteBefehle.clear;
if istDasBefehl('Ende',s,bekannteBefehle,false) then break;
- if istDasBefehl('xmin:',s,bekannteBefehle,true) then begin
- xmin:=kont2disk('x',exprtofloat(st,s));
+ if istDasBefehl('xMin:',s,bekannteBefehle,true) then begin
+ xMin:=kont2disk('x',exprToFloat(sT,s));
continue;
end;
- if istDasBefehl('xmax:',s,bekannteBefehle,true) then begin
- xmax:=kont2disk('x',exprtofloat(st,s));
+ if istDasBefehl('xMax:',s,bekannteBefehle,true) then begin
+ xMax:=kont2disk('x',exprToFloat(sT,s));
continue;
end;
- if istDasBefehl('tmin:',s,bekannteBefehle,true) then begin
- tmin:=kont2disk('t',exprtofloat(st,s));
+ if istDasBefehl('tMin:',s,bekannteBefehle,true) then begin
+ tMin:=kont2disk('t',exprToFloat(sT,s));
continue;
end;
- if istDasBefehl('tmax:',s,bekannteBefehle,true) then begin
- tmax:=kont2disk('t',exprtofloat(st,s));
+ if istDasBefehl('tMax:',s,bekannteBefehle,true) then begin
+ tMax:=kont2disk('t',exprToFloat(sT,s));
continue;
end;
bekannteBefehle.sort;
@@ -2530,31 +2536,31 @@ begin
until false;
bekannteBefehle.free;
- _xsteps:=xmax-xmin+1;
- _tsiz:=tmax-tmin+1;
- if (wertes^[faktor1].Transformationen.xstart<>wertes^[faktor2].Transformationen.xstart) or
- (wertes^[faktor1].Transformationen.xstop<>wertes^[faktor2].Transformationen.xstop) or
- (wertes^[faktor1].Transformationen.tstart<>wertes^[faktor2].Transformationen.tstart) or
- (wertes^[faktor1].Transformationen.tstop<>wertes^[faktor2].Transformationen.tstop) or
- (wertes^[faktor1]._xsteps<>wertes^[faktor2]._xsteps) or
- (wertes^[faktor1]._tsiz<>wertes^[faktor2]._tsiz) then begin
+ _xSteps:=xMax-xMin+1;
+ _tSiz:=tMax-tMin+1;
+ if (wertes^[faktor1].transformationen.xStart<>wertes^[faktor2].transformationen.xStart) or
+ (wertes^[faktor1].transformationen.xStop<>wertes^[faktor2].transformationen.xStop) or
+ (wertes^[faktor1].transformationen.tStart<>wertes^[faktor2].transformationen.tStart) or
+ (wertes^[faktor1].transformationen.tStop<>wertes^[faktor2].transformationen.tStop) or
+ (wertes^[faktor1]._xSteps<>wertes^[faktor2]._xSteps) or
+ (wertes^[faktor1]._tSiz<>wertes^[faktor2]._tSiz) then begin
gibAus('Faktor1 und Faktor2 haben verschiedene Abmessungen, sowas verstehe ich nicht!',3);
exit;
end;
- Transformationen:=tKoordinatenAusschnitt.create(Transformationen,xmin,xmax,tmin,tmax);
+ transformationen:=tKoordinatenAusschnitt.create(transformationen,xMin,xMax,tMin,tMax);
_np:=wertes^[faktor1]._np;
_beta:=wertes^[faktor1]._beta;
- Genauigkeit:=gExtended;
- if st then begin
+ genauigkeit:=gExtended;
+ if sT then begin
result:=true;
exit;
end;
- eWerte.holeRam(3);
+ holeRAM(3);
gibAus('Berechne ...',3);
Zeit:=now;
- setlength(produktThreads,threads);
+ setLength(produktThreads,threads);
for i:=0 to length(produktThreads)-1 do
- produktThreads[i]:=tProduktThread.create(wertes^[faktor1],wertes^[faktor2],self,round(i*_xsteps/threads),round((i+1)*_xsteps/threads-1),0,_tsiz-1,xmin,tmin);
+ produktThreads[i]:=tProduktThread.create(wertes^[faktor1],wertes^[faktor2],self,round(i*_xSteps/threads),round((i+1)*_xSteps/threads-1),0,_tSiz-1,xMin,tMin);
repeat
sleep(10);
fertig:=true;
@@ -2567,7 +2573,7 @@ begin
result:=true;
end;
-function tWerte.berechneKorrelation(st: boolean; f: tMyStringlist; threads: longint; quelle: tWerte): boolean;
+function tWerte.berechneKorrelation(sT: boolean; f: tMyStringList; threads: longint; quelle: tWerte): boolean;
var
i: longint;
s: string;
@@ -2578,18 +2584,18 @@ var
bekannteBefehle: tMyStringList;
begin
result:=false;
- warteaufBeendigungDesLeseThreads;
+ warteAufBeendigungDesLeseThreads;
genauigkeit:=gExtended;
wavelet:=tWavelet.create;
wavelet.mitFFT:=false;
Zeit:=now;
- Transformationen:=quelle.Transformationen;
+ transformationen:=quelle.transformationen;
wavelet.freq:=0;
wavelet.tfwhm:=1;
wavelet.typ:=wtSin2;
- _xsteps:=quelle._xsteps;
- _tsiz:=quelle._tsiz;
+ _xSteps:=quelle._xSteps;
+ _tSiz:=quelle._tSiz;
_np:=quelle._np;
_beta:=quelle._beta;
bekannteBefehle:=tMyStringList.create;
@@ -2602,11 +2608,11 @@ begin
bekannteBefehle.clear;
if istDasBefehl('Ende',s,bekannteBefehle,false) then break;
if istDasBefehl('freq:',s,bekannteBefehle,true) then begin
- wavelet.freq:=1/kont2diskFak('t',1/exprtofloat(st,s));
+ wavelet.freq:=1/kont2diskFak('t',1/exprToFloat(sT,s));
continue;
end;
if istDasBefehl('tfwhm:',s,bekannteBefehle,true) then begin
- wavelet.tfwhm:=round(kont2diskFak('t',exprtofloat(st,s)));
+ wavelet.tfwhm:=round(kont2diskFak('t',exprToFloat(sT,s)));
continue;
end;
if istDasBefehl('Wavelettyp:',s,bekannteBefehle,true) then begin
@@ -2628,36 +2634,36 @@ begin
until false;
bekannteBefehle.free;
- if st then begin
+ if sT then begin
result:=true;
exit;
end;
if wavelet.mitFFT then begin
- gibAus('Fordere '+inttostr(floor(_tsiz*_xsteps*sizeof(extended)/1024/1024))+' MB RAM an ('+inttostr(_xsteps)+' x-Schritte mal '+inttostr(_tsiz)+' t-Schritte). ...',3);
+ gibAus('Fordere '+intToStr(floor(_tSiz*_xSteps*sizeOf(extended)/1024/1024))+' MB RAM an ('+intToStr(_xSteps)+' x-Schritte mal '+intToStr(_tSiz)+' t-Schritte). ...',3);
gibAus(paramsDump,3);
gibAus(quelle.paramsDump,3);
case quelle.genauigkeit of
- gSingle: eWerte.kopiereVon(st,pTLLWerteSingle(@quelle.sWerte));
- gDouble: dWerte.kopiereVon(st,pTLLWerteDouble(@quelle.dWerte));
- gExtended: eWerte.kopiereVon(st,pTLLWerteExtended(@quelle.eWerte));
+ gSingle: eWerte.kopiereVon(sT,pTLLWerteSingle(@quelle.sWerte));
+ gDouble: dWerte.kopiereVon(sT,pTLLWerteDouble(@quelle.dWerte));
+ gExtended: eWerte.kopiereVon(sT,pTLLWerteExtended(@quelle.eWerte));
end{of case};
gibAus('... fertig '+timetostr(now-Zeit)+', berechne ...',3);
end
else begin
genauigkeit:=gExtended;
- eWerte.holeRam(3);
+ holeRAM(3);
gibAus('Berechne ...',3);
end;
Zeit:=now;
- wavelet.werte.params.tsiz:=_tsiz;
+ wavelet.werte.params.tSiz:=_tSiz;
wavelet.werte.params.refreshKnownValues;
if not wavelet.berechneWerte then begin
gibAus('Es traten Fehler bei der Waveletberechnung auf!',3);
exit;
end;
- setlength(korrelThreads,threads);
+ setLength(korrelThreads,threads);
for i:=0 to length(korrelThreads)-1 do
- korrelThreads[i]:=tKorrelThread.create(quelle,self,round(i*_xsteps/threads),round((i+1)*_xsteps/threads-1),wavelet);
+ korrelThreads[i]:=tKorrelThread.create(quelle,self,round(i*_xSteps/threads),round((i+1)*_xSteps/threads-1),wavelet);
repeat
sleep(10);
fertig:=true;
@@ -2669,37 +2675,37 @@ begin
pvFehler:=pvFehler+korrelThreads[i].pvFehler;
korrelThreads[i].free;
end;
- gibAus(' (Parseval-Fehler = '+floattostr(pvFehler/length(korrelThreads))+')',3);
+ gibAus(' (Parseval-Fehler = '+floatToStr(pvFehler/length(korrelThreads))+')',3);
wavelet.free;
gibAus('... fertig '+timetostr(now-Zeit),3);
result:=true;
end;
-procedure tWerte.ermittleMinMaxDichten(st: boolean; threads: longint; symmetrisch: boolean);
+procedure tWerte.ermittleMinMaxDichten(sT: boolean; threads: longint; symmetrisch: boolean);
begin
- ermittleMinMaxDichten(st,threads,0,_xsteps-1,0,_tsiz-1,symmetrisch);
+ ermittleMinMaxDichten(sT,threads,0,_xSteps-1,0,_tSiz-1,symmetrisch);
end;
-procedure tWerte.ermittleMinMaxDichten(st: boolean; threads,xmin,xmax,tmin,tmax: longint; symmetrisch: boolean);
+procedure tWerte.ermittleMinMaxDichten(sT: boolean; threads,xMin,xMax,tMin,tMax: longint; symmetrisch: boolean);
var
i,j: longint;
DTs: array of tDichteThread;
fertig: boolean;
Zeit: extended;
begin
- if st then begin
+ if sT then begin
if _minW>=_maxW then _maxW:=_minW+1;
exit;
end;
- warteaufBeendigungDesLeseThreads;
+ warteAufBeendigungDesLeseThreads;
Zeit:=now;
- setlength(DTs,min(threads,xmax+1-xmin));
+ setLength(DTs,min(threads,xMax+1-xMin));
gibAus('Ermittle maximale und minimale Dichten ...',3);
- j:=xmin;
+ j:=xMin;
for i:=0 to length(DTs)-1 do begin
- DTs[i]:=tDichteThread.create(j,Byte(i=length(DTs)-1)*xmax + Byte(i<length(DTs)-1)*(j+ ((xmax+1-xmin) div length(DTs))),tmin,tmax,self);
- j:=Byte(i=length(DTs)-1)*xmax + Byte(i<length(DTs)-1)*(j+((xmax+1-xmin) div length(DTs)))+1;
- gibAus('Dichtethread '+inttostr(i)+' gestartet!',1);
+ DTs[i]:=tDichteThread.create(j,byte(i=length(DTs)-1)*xMax + byte(i<length(DTs)-1)*(j+ ((xMax+1-xMin) div length(DTs))),tMin,tMax,self);
+ j:=byte(i=length(DTs)-1)*xMax + byte(i<length(DTs)-1)*(j+((xMax+1-xMin) div length(DTs)))+1;
+ gibAus('Dichtethread '+intToStr(i)+' gestartet!',1);
end;
repeat
sleep(10);
@@ -2715,22 +2721,22 @@ begin
_minW:=min(_minW,DTs[i].minDichte);
DTs[i].free;
end;
- gibAus('... sie sind '+myfloattostr(_minW)+' und '+myfloattostr(_maxW)+'. '+timetostr(now-Zeit),3);
+ gibAus('... sie sind '+myFloatToStr(_minW)+' und '+myFloatToStr(_maxW)+'. '+timetostr(now-Zeit),3);
if symmetrisch then begin
_minW:=min(_minW,-_maxW);
_maxW:=max(_maxW,-_minW);
- gibAus('Jetzt sind sie '+myfloattostr(_minW)+' und '+myfloattostr(_maxW)+'. '+timetostr(now-Zeit),3);
+ gibAus('Jetzt sind sie '+myFloatToStr(_minW)+' und '+myFloatToStr(_maxW)+'. '+timetostr(now-Zeit),3);
end;
end;
-procedure tWerte.gleicheMinMaxDichtenAn(st: boolean; f: tMyStringlist; symmetrisch: boolean);
+procedure tWerte.gleicheMinMaxDichtenAn(sT: boolean; f: tMyStringList; symmetrisch: boolean);
var
i: longint;
s: string;
Zeit: extended;
vgWs: array of tWerte;
begin
- setlength(vgWs,0);
+ setLength(vgWs,0);
repeat
if not f.metaReadln(s,true) then begin
@@ -2738,23 +2744,23 @@ begin
exit;
end;
if s='Ende' then break;
- setlength(vgWs,length(vgWs)+1);
- vgWs[length(vgWs)-1]:=wertes^[findeWerte(s,nil,wertes,Konturen,false)];
+ setLength(vgWs,length(vgWs)+1);
+ vgWs[length(vgWs)-1]:=wertes^[findeWerte(s,nil,wertes,konturen,false)];
until false;
- if st then begin
+ if sT then begin
if _minW>=_maxW then _maxW:=_minW+1;
exit;
end;
- warteaufBeendigungDesLeseThreads;
+ warteAufBeendigungDesLeseThreads;
for i:=0 to length(vgWs)-1 do
vgWs[i].warteAufBeendigungDesLeseThreads;
Zeit:=now;
gibAus('Gleiche maximale und minimale Dichten an ...',3);
for i:=0 to length(vgWs)-1 do begin
- _minW:=min(_minW,vgWs[i]._minw);
- _maxW:=max(_maxW,vgWs[i]._maxw);
+ _minW:=min(_minW,vgWs[i]._minW);
+ _maxW:=max(_maxW,vgWs[i]._maxW);
end;
if symmetrisch then begin
@@ -2763,47 +2769,57 @@ begin
end;
for i:=0 to length(vgWs)-1 do begin
- vgWs[i]._minw:=_minW;
- vgWs[i]._maxw:=_maxW;
+ vgWs[i]._minW:=_minW;
+ vgWs[i]._maxW:=_maxW;
end;
- gibAus('... sie sind '+myfloattostr(_minW)+' und '+myfloattostr(_maxW)+'. '+timetostr(now-Zeit),3);
+ gibAus('... sie sind '+myFloatToStr(_minW)+' und '+myFloatToStr(_maxW)+'. '+timetostr(now-Zeit),3);
if symmetrisch then begin
_minW:=min(_minW,-_maxW);
_maxW:=max(_maxW,-_minW);
- gibAus('Jetzt sind sie '+myfloattostr(_minW)+' und '+myfloattostr(_maxW)+'. '+timetostr(now-Zeit),3);
+ gibAus('Jetzt sind sie '+myFloatToStr(_minW)+' und '+myFloatToStr(_maxW)+'. '+timetostr(now-Zeit),3);
end;
end;
function tWerte.fft(threads: longint; senkrecht,invers: boolean; const vor,nach: tFFTDatenordnung; fen: tFenster; hg: extended; out pvFehler: extended; Warn: tWarnstufe): boolean;
var
- fftThreads: array of tFFTThread;
- i: longint;
- fertig: boolean;
+ fftThreads: array of tFFTThread;
+ i: int64;
+ fertig: boolean;
begin
result:=false;
+
+ if (vor in [doAlleResIms,doAlleResSmi]) xor (nach in [doAlleResIms,doAlleResSmi]) then begin
+ gibAus('Eine FFT kann nicht von voll-komplex zu halb-komplex oder umgekehrt transformieren - das muss außerhalb erledigt werden ('+fftDoToStr(vor)+' -> '+fftDoToStr(nach)+')!',3);
+ exit;
+ end;
+ if (vor in [doGetrennt]) or (nach in [doGetrennt]) then begin
+ gibAus('tWerte.fft kann nicht mit getrenntem Input oder Output umgehen!',3);
+ exit;
+ end;
+
if senkrecht then begin
if assigned(fen) and
- (length(fen.Werte)<>_tsiz) then
- fen.berechneWerte(_tsiz);
- if threads>_xsteps then
- threads:=_xsteps;
+ (length(fen.werte)<>_tSiz) then
+ fen.berechneWerte(_tSiz);
+ if threads>_xSteps then
+ threads:=_xSteps;
end
else begin
if assigned(fen) and
- (length(fen.Werte)<>_xsteps) then
- fen.berechneWerte(_xsteps);
- if threads>_tsiz then
- threads:=_tsiz;
+ (length(fen.werte)<>_xSteps) then
+ fen.berechneWerte(_xSteps);
+ if threads>_tSiz then
+ threads:=_tSiz;
end;
- setlength(fftThreads,threads);
+ setLength(fftThreads,threads);
if senkrecht then begin
fftThreads[0]:=
tFFTThread.create(
self,
0,
- round(_xsteps/threads-1),
+ round(_xSteps/threads-1),
senkrecht,
invers,
vor,
@@ -2814,8 +2830,8 @@ begin
fftThreads[i]:=
tFFTThread.create(
self,
- round(_xsteps/threads*i),
- round(_xsteps/threads*(i+1)-1),
+ round(_xSteps/threads*i),
+ round(_xSteps/threads*(i+1)-1),
senkrecht,
invers,
fftThreads[0].algo,
@@ -2827,7 +2843,7 @@ begin
tFFTThread.create(
self,
0,
- round(_tsiz/threads-1),
+ round(_tSiz/threads-1),
senkrecht,
invers,
vor,
@@ -2838,8 +2854,8 @@ begin
fftThreads[i]:=
tFFTThread.create(
self,
- round(_tsiz/threads*i),
- round(_tsiz/threads*(i+1)-1),
+ round(_tSiz/threads*i),
+ round(_tSiz/threads*(i+1)-1),
senkrecht,
invers,
fftThreads[0].algo,
@@ -2861,21 +2877,21 @@ begin
fftThreads[i].free;
end;
pvFehler:=pvFehler/length(fftThreads);
- gibAus(' (Parseval-Fehler = '+floattostr(pvFehler)+')',1);
+ gibAus(' (Parseval-Fehler = '+floatToStr(pvFehler)+')',1);
gibAus('Alle FFTThreads fertig!',1);
end;
-procedure tWerte.initFuerGauszFit(st: boolean; daten: tWerte; senkrecht: boolean; adLaenge: longint; adStart,adStop: extended);
+procedure tWerte.initFuerGauszFit(sT: boolean; daten: tWerte; senkrecht: boolean; adLaenge: longint; adStart,adStop: extended);
begin
- Transformationen:=tFitTransformation.create(daten.Transformationen,senkrecht,adLaenge,adStart,adStop);
- _xsteps:=Transformationen.xsteps;
- _tsiz:=Transformationen.tsiz;
- Genauigkeit:=gExtended;
- if not st then
- eWerte.holeRam(3);
+ transformationen:=tFitTransformation.create(daten.transformationen,senkrecht,adLaenge,adStart,adStop);
+ _xSteps:=transformationen.xSteps;
+ _tSiz:=transformationen.tSiz;
+ genauigkeit:=gExtended;
+ if not sT then
+ holeRAM(3);
end;
-function tWerte.fitteGausze(st: boolean; f: tMyStringlist; threads: longint): boolean;
+function tWerte.fitteGausze(sT: boolean; f: tMyStringList; threads: longint): boolean;
var
Zeit: extended;
senkrecht,fertig: boolean;
@@ -2889,7 +2905,7 @@ var
begin
result:=false;
Zeit:=now;
- if not st then
+ if not sT then
gibAus('Gauße fitten ...',3);
ampl:=nil;
br:=nil;
@@ -2900,7 +2916,7 @@ begin
maxBreite:=-1;
maxVerschiebung:=-1;
fensterBreite:=-1;
- setlength(posiMitten,0);
+ setLength(posiMitten,0);
bekannteBefehle:=tMyStringList.create;
repeat
if not f.metaReadln(s,true) then begin
@@ -2973,20 +2989,20 @@ begin
continue;
end;
if istDasBefehl('Maximalverschiebung:',s,bekannteBefehle,true) then begin
- maxVerschiebung:=kont2diskFak(senkrecht,exprtofloat(st,s));
+ maxVerschiebung:=kont2diskFak(senkrecht,exprToFloat(sT,s));
continue;
end;
if istDasBefehl('Maximalbreite:',s,bekannteBefehle,true) then begin
- maxBreite:=kont2diskFak(senkrecht,exprtofloat(st,s));
+ maxBreite:=kont2diskFak(senkrecht,exprToFloat(sT,s));
continue;
end;
if istDasBefehl('Fensterbreite:',s,bekannteBefehle,true) then begin
- fensterBreite:=kont2diskFak(senkrecht,exprtofloat(st,s));
+ fensterBreite:=kont2diskFak(senkrecht,exprToFloat(sT,s));
continue;
end;
if istDasBefehl('Positionsbereichsmitten:',s,bekannteBefehle,true) then begin
while s<>'' do
- fuegeSortiertHinzu(kont2disk(senkrecht,exprToFloat(st,erstesArgument(s))),posiMitten);
+ fuegeSortiertHinzu(kont2disk(senkrecht,exprToFloat(sT,erstesArgument(s))),posiMitten);
continue;
end;
bekannteBefehle.sort;
@@ -3010,30 +3026,30 @@ begin
end;
if assigned(ampl) then
- ampl.initFuerGauszFit(st,self,senkrecht,length(posiMitten),posiMitten[0],posiMitten[length(posiMitten)-1]);
+ ampl.initFuerGauszFit(sT,self,senkrecht,length(posiMitten),posiMitten[0],posiMitten[length(posiMitten)-1]);
if assigned(br) then
- br.initFuerGauszFit(st,self,senkrecht,length(posiMitten),posiMitten[0],posiMitten[length(posiMitten)-1]);
+ br.initFuerGauszFit(sT,self,senkrecht,length(posiMitten),posiMitten[0],posiMitten[length(posiMitten)-1]);
if assigned(posi) then
- posi.initFuerGauszFit(st,self,senkrecht,length(posiMitten),posiMitten[0],posiMitten[length(posiMitten)-1]);
+ posi.initFuerGauszFit(sT,self,senkrecht,length(posiMitten),posiMitten[0],posiMitten[length(posiMitten)-1]);
if assigned(ueberl) then
- ueberl.initFuerGauszFit(st,self,senkrecht,length(posiMitten),posiMitten[0],posiMitten[length(posiMitten)-1]);
+ ueberl.initFuerGauszFit(sT,self,senkrecht,length(posiMitten),posiMitten[0],posiMitten[length(posiMitten)-1]);
if assigned(hint) then
- hint.initFuerGauszFit(st,self,senkrecht,length(posiMitten),posiMitten[0],posiMitten[length(posiMitten)-1]);
+ hint.initFuerGauszFit(sT,self,senkrecht,length(posiMitten),posiMitten[0],posiMitten[length(posiMitten)-1]);
if senkrecht then
- iterDim:=_xsteps
+ iterDim:=_xSteps
else
- iterDim:=_tsiz;
+ iterDim:=_tSiz;
if threads > iterDim then
threads:=iterDim;
- if st then begin
+ if sT then begin
result:=true;
exit;
end;
- setlength(gauszFitThreads,threads);
+ setLength(gauszFitThreads,threads);
for i:=0 to threads-1 do
gauszFitThreads[i]:=
tGauszFitThread.create(
@@ -3066,9 +3082,9 @@ begin
result:=true;
end;
-function tWerte.berechneZeitfrequenzanalyse(st: boolean; f: tMyStringlist; threads: longint; quelle: tWerte; Warn: tWarnstufe): boolean;
+function tWerte.berechneZeitfrequenzanalyse(sT: boolean; f: tMyStringList; threads: longint; quelle: tWerte; Warn: tWarnstufe): boolean;
var
- i,tmin,tmax,qlen: longint;
+ i,tMin,tMax,qlen: longint;
Zeit,pvFehler,total: extended;
wavelet: tGauszFenster;
fenster: tSin2Fenster;
@@ -3078,22 +3094,22 @@ var
bekannteBefehle: tMyStringList;
begin
result:=false;
- if not ((quelle._xsteps<>1) xor (quelle._tsiz<>1)) then begin
- gibAus('Eine Zeitfrequenzanalyse geht nur auf eindimensionalen Daten! ('+inttostr(quelle._xsteps)+'x'+inttostr(quelle._tsiz)+')',3);
+ if not ((quelle._xSteps<>1) xor (quelle._tSiz<>1)) then begin
+ gibAus('Eine Zeitfrequenzanalyse geht nur auf eindimensionalen Daten! ('+intToStr(quelle._xSteps)+'x'+intToStr(quelle._tSiz)+')',3);
exit;
end;
- warteaufBeendigungDesLeseThreads;
- senkrecht:=quelle._tsiz<>1;
- tmin:=0;
+ warteAufBeendigungDesLeseThreads;
+ senkrecht:=quelle._tSiz<>1;
+ tMin:=0;
rundeAuf2:=false;
if senkrecht then
- tmax:=quelle._tsiz-1
+ tMax:=quelle._tSiz-1
else
- tmax:=quelle._xsteps-1;
+ tMax:=quelle._xSteps-1;
Zeit:=now;
wavelet:=tGauszFenster.create;
fenster:=tSin2Fenster.create;
- Genauigkeit:=gExtended;
+ genauigkeit:=gExtended;
bekannteBefehle:=tMyStringList.create;
repeat
if not f.metaReadln(s,true) then begin
@@ -3105,12 +3121,12 @@ begin
bekannteBefehle.clear;
if istDasBefehl('Ende',s,bekannteBefehle,false) then break;
if istDasBefehl('Breite:',s,bekannteBefehle,true) then begin
- wavelet.breite:=quelle.kont2diskFak(senkrecht,quelle.exprtofloat(st,s));
+ wavelet.breite:=quelle.kont2diskFak(senkrecht,quelle.exprToFloat(sT,s));
wavelet.aktiv:=true;
continue;
end;
if istDasBefehl('Rand:',s,bekannteBefehle,true) then begin
- fenster.rand:=round(quelle.kont2diskFak(senkrecht,quelle.exprtofloat(st,s)));
+ fenster.rand:=round(quelle.kont2diskFak(senkrecht,quelle.exprToFloat(sT,s)));
fenster.aktiv:=true;
continue;
end;
@@ -3123,22 +3139,22 @@ begin
continue;
end;
if senkrecht then begin
- if istDasBefehl('tmin:',s,bekannteBefehle,true) or istDasBefehl('ymin:',s,bekannteBefehle,true) then begin
- tmin:=round(quelle.kont2disk('t',quelle.exprtofloat(st,s)));
+ if istDasBefehl('tMin:',s,bekannteBefehle,true) or istDasBefehl('yMin:',s,bekannteBefehle,true) then begin
+ tMin:=round(quelle.kont2disk('t',quelle.exprToFloat(sT,s)));
continue;
end;
- if istDasBefehl('tmax:',s,bekannteBefehle,true) or istDasBefehl('ymax:',s,bekannteBefehle,true) then begin
- tmax:=round(quelle.kont2disk('t',quelle.exprtofloat(st,s)));
+ if istDasBefehl('tMax:',s,bekannteBefehle,true) or istDasBefehl('yMax:',s,bekannteBefehle,true) then begin
+ tMax:=round(quelle.kont2disk('t',quelle.exprToFloat(sT,s)));
continue;
end;
end;
if senkrecht then begin
- if istDasBefehl('xmin:',s,bekannteBefehle,true) then begin
- tmin:=round(quelle.kont2disk('x',quelle.exprtofloat(st,s)));
+ if istDasBefehl('xMin:',s,bekannteBefehle,true) then begin
+ tMin:=round(quelle.kont2disk('x',quelle.exprToFloat(sT,s)));
continue;
end;
- if istDasBefehl('xmax:',s,bekannteBefehle,true) then begin
- tmax:=round(quelle.kont2disk('x',quelle.exprtofloat(st,s)));
+ if istDasBefehl('xMax:',s,bekannteBefehle,true) then begin
+ tMax:=round(quelle.kont2disk('x',quelle.exprToFloat(sT,s)));
continue;
end;
end;
@@ -3152,46 +3168,46 @@ begin
bekannteBefehle.free;
if senkrecht then
- qlen:=quelle._tsiz
+ qlen:=quelle._tSiz
else
- qlen:=quelle._xsteps;
+ qlen:=quelle._xSteps;
- tmin:=max(tmin,0);
- tmax:=min(tmax,qlen-1);
- _xsteps:=tmax+1-tmin;
+ tMin:=max(tMin,0);
+ tMax:=min(tMax,qlen-1);
+ _xSteps:=tMax+1-tMin;
if rundeAuf2 then begin
- _xsteps:=round(power(2,round(ln(_xsteps)/ln(2))));
- if _xsteps>qlen then
- _xsteps:=_xsteps div 2;
- tmax:=(tmin+tmax+_xsteps) div 2;
- tmin:=tmax+1-_xsteps;
- if tmin<0 then begin
- tmin:=0;
- tmax:=_xsteps-1;
- end;
- if tmax>=qlen then begin
- tmax:=qlen-1;
- tmin:=tmax+1-_xsteps;
- end;
- if tmin<0 then begin
+ _xSteps:=round(power(2,round(ln(_xSteps)/ln(2))));
+ if _xSteps>qlen then
+ _xSteps:=_xSteps div 2;
+ tMax:=(tMin+tMax+_xSteps) div 2;
+ tMin:=tMax+1-_xSteps;
+ if tMin<0 then begin
+ tMin:=0;
+ tMax:=_xSteps-1;
+ end;
+ if tMax>=qlen then begin
+ tMax:=qlen-1;
+ tMin:=tMax+1-_xSteps;
+ end;
+ if tMin<0 then begin
gibAus('Das Fenster passt nicht in die Werte - das sollte nicht passieren können! ('+
- inttostr(tmin)+'..'+
- inttostr(tmax)+': '+
- inttostr(qlen)+' ('+
- inttostr(quelle._xsteps)+'x'+
- inttostr(quelle._tsiz)+'))',3);
+ intToStr(tMin)+'..'+
+ intToStr(tMax)+': '+
+ intToStr(qlen)+' ('+
+ intToStr(quelle._xSteps)+'x'+
+ intToStr(quelle._tSiz)+'))',3);
wavelet.free;
fenster.free;
exit;
end;
end;
- _tsiz:=_xsteps;
- if wavelet.breite>_xsteps then begin
+ _tSiz:=_xSteps;
+ if wavelet.breite>_xSteps then begin
gibAus('Die angegebene Breite ist größer als die Anzahl der Werte! ('+
floattostrtrunc(wavelet.breite,2,true)+'>='+
- inttostr(_xsteps)+')',3);
+ intToStr(_xSteps)+')',3);
wavelet.free;
fenster.free;
exit;
@@ -3206,34 +3222,34 @@ begin
fenster.berechneWerte(qlen,true);
if senkrecht then
- Transformationen:=tKoordinatenAusschnitt.create(quelle.Transformationen,0,0,tmin,tmax)
+ transformationen:=tKoordinatenAusschnitt.create(quelle.transformationen,0,0,tMin,tMax)
else
- Transformationen:=tKoordinatenAusschnitt.create(quelle.Transformationen,tmin,tmax,0,0);
- Transformationen:=tDiagonaleAgglomeration.create(Transformationen);
+ transformationen:=tKoordinatenAusschnitt.create(quelle.transformationen,tMin,tMax,0,0);
+ transformationen:=tDiagonaleAgglomeration.create(transformationen);
- if not st then begin
+ if not sT then begin
total:=0;
- tmin:=tmin - _xsteps div 2;
- while tmin<0 do
- tmin:=tmin+qlen;
+ tMin:=tMin - _xSteps div 2;
+ while tMin<0 do
+ tMin:=tMin+qlen;
- eWerte.holeRam(3);
- setlength(tmpW,2*_xsteps-1);
+ holeRAM(3);
+ setLength(tmpW,2*_xSteps-1);
gibAus('kopiere Inhalt ...',3);
- case quelle.Genauigkeit of
+ case quelle.genauigkeit of
gSingle:
- for i:=0 to 2*_xsteps-2 do
- tmpW[i]:=quelle.sWerte.werte[(i+tmin) mod qlen] * fenster.werte[(i+tmin) mod qlen];
+ for i:=0 to 2*_xSteps-2 do
+ tmpW[i]:=quelle.sWerte.werte[(i+tMin) mod qlen] * fenster.werte[(i+tMin) mod qlen];
gDouble:
- for i:=0 to 2*_xsteps-2 do
- tmpW[i]:=quelle.dWerte.werte[(i+tmin) mod qlen] * fenster.werte[(i+tmin) mod qlen];
+ for i:=0 to 2*_xSteps-2 do
+ tmpW[i]:=quelle.dWerte.werte[(i+tMin) mod qlen] * fenster.werte[(i+tMin) mod qlen];
gExtended:
- for i:=0 to 2*_xsteps-2 do
- tmpW[i]:=quelle.eWerte.werte[(i+tmin) mod qlen] * fenster.werte[(i+tmin) mod qlen];
+ for i:=0 to 2*_xSteps-2 do
+ tmpW[i]:=quelle.eWerte.werte[(i+tMin) mod qlen] * fenster.werte[(i+tMin) mod qlen];
end{of case};
- for i:=0 to _xsteps-1 do
- move(tmpW[i],eWerte.werte[i*_xsteps],_xsteps*sizeof(extended));
+ for i:=0 to _xSteps-1 do
+ move(tmpW[i],eWerte.werte[i*_xSteps],_xSteps*sizeOf(extended));
for i:=0 to length(eWerte.werte)-1 do
total:=total+sqr(eWerte.werte[i]);
gibAus('... fertig ('+floatToStr(total)+'), berechne Fouriertransformation ...',3);
@@ -3246,15 +3262,15 @@ begin
total:=0;
for i:=0 to length(eWerte.werte)-1 do
total:=total+sqr(eWerte.werte[i]);
- gibAus(' (Parseval-Fehler = '+floattostr(pvFehler)+') -> '+floattostr(total),3);
+ gibAus(' (Parseval-Fehler = '+floatToStr(pvFehler)+') -> '+floatToStr(total),3);
end;
- Transformationen:=tFFTTransformation.create(Transformationen,not senkrecht,senkrecht);
+ transformationen:=tFFTTransformation.create(transformationen,not senkrecht,senkrecht);
if senkrecht then // die zweite Hälfte der Werte ist redundant
- _tsiz:=_tsiz div 2 + 1
+ _tSiz:=_tSiz div 2 + 1
else
- _xsteps:=_xsteps div 2 + 1;
- Transformationen:=tKoordinatenAusschnitt.create(Transformationen,0,_xsteps-1,0,_tsiz-1);
- if not st then
+ _xSteps:=_xSteps div 2 + 1;
+ transformationen:=tKoordinatenAusschnitt.create(transformationen,0,_xSteps-1,0,_tSiz-1);
+ if not sT then
eWerte.holeRAM(0);
gibAus('... fertig '+timetostr(now-Zeit),3);
wavelet.free;
@@ -3262,13 +3278,13 @@ begin
result:=true;
end;
-function tWerte.berechneVerzerrung(st: boolean; f: tMyStringlist; threads: longint; 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;
- ZPs: tIntPointArray; // Zielpositionen
- ZGs: tExtPointArray; // Zielgewichte
- ZAs: tExtendedArray; // Anzahl Quellen, die auf entsprechende Zielposition abgebildet werden
+ zPs: tIntPointArray; // Zielpositionen
+ zGs: tExtPointArray; // Zielgewichte
+ zAs: tExtendedArray; // Anzahl quellen, die auf entsprechende Zielposition abgebildet werden
Zeit,epsilon: extended;
Vorbearbeitung,
Nachbearbeitung,
@@ -3286,27 +3302,27 @@ begin
for ii:=0 to length(verzerrThreads)-1 do
if assigned(verzerrThreads[ii]) then
verzerrThreads[ii].free;
- setlength(verzerrThreads,0);
+ setLength(verzerrThreads,0);
if bearbeitungenLoeschen then begin
zerstoereTransformationWennObsolet(Vorbearbeitung);
zerstoereTransformationWennObsolet(Nachbearbeitung);
- zerstoereTransformationWennObsolet(Verzerrung);
+ zerstoereTransformationWennObsolet(verzerrung);
end;
- setlength(ZPs,0);
- setlength(ZGs,0);
- setlength(ZAs,0);
+ setLength(zPs,0);
+ setLength(zGs,0);
+ setLength(zAs,0);
bekannteBefehle.free;
end;
begin
result:=false;
- warteaufBeendigungDesLeseThreads;
+ warteAufBeendigungDesLeseThreads;
gibAus('Verzerrung berechnen ... ',3);
Zeit:=now;
bearbeitungenLoeschen:=true;
verzerrung:=tKeineTransformation.create;
verAnz:=0;
epsilon:=1e-9;
- Genauigkeit:=gExtended;
+ genauigkeit:=gExtended;
Vorbearbeitung:=tKeineTransformation.create;
vorAnz:=0;
Nachbearbeitung:=tKeineTransformation.create;
@@ -3320,13 +3336,13 @@ begin
end;
bekannteBefehle.clear;
if istDasBefehl('Ende',s,bekannteBefehle,false) then break;
- if quelle.dichtenParameterErkannt(st,s,bekannteBefehle,threads,0,_xsteps-1,0,_tsiz-1) then continue;
+ if quelle.dichtenParameterErkannt(sT,s,bekannteBefehle,threads,0,_xSteps-1,0,_tSiz-1) then continue;
if istDasBefehl('Threadanzahl:',s,bekannteBefehle,true) then begin
threads:=strtoint(s);
continue;
end;
if istDasBefehl('Epsilon:',s,bekannteBefehle,true) then begin
- epsilon:=exprtofloat(st,s);
+ epsilon:=exprToFloat(sT,s);
continue;
end;
if istDasBefehl('Abbildung:',s,bekannteBefehle,true) then begin
@@ -3334,24 +3350,24 @@ begin
if assigned(verzerrung) then
tmp.fuegeVorgaengerHinzu(verzerrung);
verzerrung:=tmp;
- if not (verzerrung as tKonkreteKoordinatenTransformation).initAbbildung(st,s,quelle.xscale,quelle.tscale,@exprtofloat) then begin
+ if not (verzerrung as tKonkreteKoordinatenTransformation).initAbbildung(sT,s,quelle.xScale,quelle.tScale,@exprToFloat) then begin
gibAus('Syntaxfehler in der Funktion '''+s+'''!',3);
aufraeumen;
exit;
end;
inc(verAnz);
- if not st then begin
+ if not sT then begin
gibAus(verzerrung.dumpParams(verAnz),3);
for i:=0 to 1 do
for j:=0 to 1 do
gibAus(
- inttostr(i*(quelle._xsteps-1))+';'+inttostr(j*(quelle._tsiz-1))+' -> '+
- tExtPointToStr(verzerrung.transformiereKoordinaten(i*(quelle._xsteps-1),j*(quelle._tsiz-1),verAnz-1)),3);
+ intToStr(i*(quelle._xSteps-1))+';'+intToStr(j*(quelle._tSiz-1))+' -> '+
+ tExtPointToStr(verzerrung.transformiereKoordinaten(i*(quelle._xSteps-1),j*(quelle._tSiz-1),verAnz-1)),3);
end;
continue;
end;
if istDasBefehl('Nachbearbeitung:',s,bekannteBefehle,true) then begin
- if not liesTWerteTransformationen(st,s,f,@exprtofloat,Nachbearbeitung) then begin
+ if not liesTWerteTransformationen(sT,s,f,@exprToFloat,Nachbearbeitung) then begin
aufraeumen;
exit;
end;
@@ -3359,7 +3375,7 @@ begin
continue;
end;
if istDasBefehl('Vorbearbeitung:',s,bekannteBefehle,true) then begin
- if not liesTWerteTransformationen(st,s,f,@exprtofloat,Vorbearbeitung) then begin
+ if not liesTWerteTransformationen(sT,s,f,@exprToFloat,Vorbearbeitung) then begin
aufraeumen;
exit;
end;
@@ -3371,31 +3387,31 @@ begin
aufraeumen;
exit;
until false;
- Transformationen:=quelle.Transformationen;
- Vorbearbeitung.ersetzeAnfangDurch(Transformationen);
- Verzerrung.ersetzeAnfangDurch(Vorbearbeitung);
+ transformationen:=quelle.transformationen;
+ Vorbearbeitung.ersetzeAnfangDurch(transformationen);
+ verzerrung.ersetzeAnfangDurch(Vorbearbeitung);
Nachbearbeitung.ersetzeAnfangDurch(verzerrung);
- if not st then begin
+ if not sT then begin
gibAus('... Zielausdehnung berechnen ... ',3);
grenzen:=(verzerrung as tKonkreteKoordinatenTransformation).zielausdehnung;
- _xsteps:=grenzen['x','y']-grenzen['x','x']+2;
- _tsiz:=grenzen['y','y']-grenzen['y','x']+2;
- if (_xsteps<=1) or (_tsiz<=1) then begin
+ _xSteps:=grenzen['x','y']-grenzen['x','x']+2;
+ _tSiz:=grenzen['y','y']-grenzen['y','x']+2;
+ if (_xSteps<=1) or (_tSiz<=1) then begin
gibAus('Es passt kein Rechteck des Ziels vollständig in die Quelldaten!',3);
aufraeumen;
exit;
end;
- eWerte.holeRam(3);
+ holeRAM(3);
gibAus('Positionen und Gewichte initialisieren ...',3);
- setlength(ZPs,quelle._xsteps*quelle._tsiz);
- setlength(ZGs,quelle._xsteps*quelle._tsiz);
- setlength(ZAs,_xsteps*_tsiz);
- initVerzerrung(quelle,0,quelle._xsteps-1,0,quelle._tsiz-1,grenzen['x','x'],grenzen['y','x'],threads,true,epsilon,verzerrung,verAnz,ZPs,ZGs,ZAs,Warn);
+ setLength(zPs,quelle._xSteps*quelle._tSiz);
+ setLength(zGs,quelle._xSteps*quelle._tSiz);
+ setLength(zAs,_xSteps*_tSiz);
+ initVerzerrung(quelle,0,quelle._xSteps-1,0,quelle._tSiz-1,grenzen['x','x'],grenzen['y','x'],threads,true,epsilon,verzerrung,verAnz,zPs,zGs,zAs,Warn);
gibAus('... fertig, Threads starten',3);
- setlength(verzerrThreads,threads);
+ setLength(verzerrThreads,threads);
for i:=0 to length(verzerrThreads)-1 do
- verzerrThreads[i]:=tVerzerrThread.create(quelle,self,round(i/length(verzerrThreads)*_xsteps),round((i+1)/length(verzerrThreads)*_xsteps-1),0,_tsiz-1,ZPs,ZGs,ZAs,Vorbearbeitung,Nachbearbeitung,vorAnz,nachAnz);
+ verzerrThreads[i]:=tVerzerrThread.create(quelle,self,round(i/length(verzerrThreads)*_xSteps),round((i+1)/length(verzerrThreads)*_xSteps-1),0,_tSiz-1,zPs,zGs,zAs,Vorbearbeitung,Nachbearbeitung,vorAnz,nachAnz);
repeat
fertig:=true;
for i:=0 to length(verzerrThreads)-1 do
@@ -3403,13 +3419,13 @@ begin
if not fertig then sleep(10);
until fertig;
end;
- Transformationen:=Nachbearbeitung;
+ transformationen:=Nachbearbeitung;
aufraeumen;
gibAus('... fertig '+timetostr(now-Zeit),3);
result:=true;
end;
-function tWerte.berechneLambdaZuOmegaVerzerrung(st: boolean; f: tMyStringList; threads: longint; quelle: tWerte): boolean;
+function tWerte.berechneLambdaZuOmegaVerzerrung(sT: boolean; f: tMyStringList; threads: longint; quelle: tWerte): boolean;
var
i: longint;
Zeit: extended;
@@ -3424,17 +3440,17 @@ begin
for ii:=0 to length(verzerrLOThreads)-1 do
if assigned(verzerrLOThreads[ii]) then
verzerrLOThreads[ii].free;
- setlength(verzerrLOThreads,0);
+ setLength(verzerrLOThreads,0);
bekannteBefehle.free;
end;
begin
result:=false;
- warteaufBeendigungDesLeseThreads;
+ warteAufBeendigungDesLeseThreads;
gibAus('lambda-zu-omega-Verzerrung berechnen ... ',3);
Zeit:=now;
- Genauigkeit:=gExtended;
- Transformationen:=tLambdaZuOmegaTransformation.create;
- Transformationen.fuegeVorgaengerHinzu(quelle.Transformationen);
+ genauigkeit:=gExtended;
+ transformationen:=tLambdaZuOmegaTransformation.create;
+ transformationen.fuegeVorgaengerHinzu(quelle.transformationen);
bekannteBefehle:=tMyStringList.create;
repeat
@@ -3445,17 +3461,17 @@ begin
end;
bekannteBefehle.clear;
if istDasBefehl('Ende',s,bekannteBefehle,false) then break;
- if quelle.dichtenParameterErkannt(st,s,bekannteBefehle,threads,0,_xsteps-1,0,_tsiz-1) then continue;
+ if quelle.dichtenParameterErkannt(sT,s,bekannteBefehle,threads,0,_xSteps-1,0,_tSiz-1) then continue;
if istDasBefehl('Threadanzahl:',s,bekannteBefehle,true) then begin
threads:=strtoint(s);
continue;
end;
if istDasBefehl('horizontal',s,bekannteBefehle,false) then begin
- (Transformationen as tLambdaZuOmegaTransformation).horizontal:=true;
+ (transformationen as tLambdaZuOmegaTransformation).horizontal:=true;
continue;
end;
if istDasBefehl('vertikal',s,bekannteBefehle,false) then begin
- (Transformationen as tLambdaZuOmegaTransformation).vertikal:=true;
+ (transformationen as tLambdaZuOmegaTransformation).vertikal:=true;
continue;
end;
bekannteBefehle.sort;
@@ -3464,23 +3480,23 @@ begin
exit;
until false;
- _xsteps:=quelle._xsteps;
- _tsiz:=quelle._tsiz;
- if not st then begin
- eWerte.holeRam(3);
+ _xSteps:=quelle._xSteps;
+ _tSiz:=quelle._tSiz;
+ if not sT then begin
+ holeRAM(3);
gibAus('Threads starten',3);
- setlength(verzerrLOThreads,threads);
+ setLength(verzerrLOThreads,threads);
for i:=0 to length(verzerrLOThreads)-1 do
verzerrLOThreads[i]:=
tVerzerrLOThread.create(
quelle,
self,
- round(i/length(verzerrLOThreads)*_xsteps),
- round((i+1)/length(verzerrLOThreads)*_xsteps-1),
+ round(i/length(verzerrLOThreads)*_xSteps),
+ round((i+1)/length(verzerrLOThreads)*_xSteps-1),
0,
- _tsiz-1,
- (Transformationen as tLambdaZuOmegaTransformation).verhaeltnisHorizontal,
- (Transformationen as tLambdaZuOmegaTransformation).verhaeltnisVertikal);
+ _tSiz-1,
+ (transformationen as tLambdaZuOmegaTransformation).verhaeltnisHorizontal,
+ (transformationen as tLambdaZuOmegaTransformation).verhaeltnisVertikal);
repeat
fertig:=true;
for i:=0 to length(verzerrLOThreads)-1 do
@@ -3493,10 +3509,10 @@ begin
result:=true;
end;
-function tWerte.entferneArtefakte(st: boolean; f: tMyStringlist; threads: longint): boolean;
+function tWerte.entferneArtefakte(sT: boolean; f: tMyStringList; threads: longint): boolean;
var
Zeit,hintergrund: extended;
- Fensters: array[boolean] of tSin2Fenster;
+ fensters: array[boolean] of tSin2Fenster;
s: string;
b,hintergrundAbziehen,fertig: boolean;
fensterThreads: array of tFensterThread;
@@ -3505,16 +3521,18 @@ var
begin
result:=false;
Zeit:=now;
- if not st then
+ if not sT then
gibAus('Artefakte entfernen ...',3);
for b:=false to true do
- Fensters[b]:=tSin2Fenster.create;
+ fensters[b]:=tSin2Fenster.create;
hintergrundAbziehen:=false;
hintergrund:=0;
bekannteBefehle:=tMyStringList.create;
repeat
if not f.metaReadln(s,true) then begin
gibAus('Unerwartetes Dateiende!',3);
+ for b:=false to true do
+ fensters[b].free;
exit;
end;
bekannteBefehle.clear;
@@ -3525,9 +3543,9 @@ begin
b:=s[1]='t';
delete(s,1,pos(':',s));
s:=trim(s);
- if b then Fensters[b].Rand:=round(kont2diskFak('t',exprtofloat(st,s)))
- else Fensters[b].Rand:=round(kont2diskFak('x',exprtofloat(st,s)));
- Fensters[b].aktiv:=true;
+ if b then fensters[b].rand:=round(kont2diskFak('t',exprToFloat(sT,s)))
+ else fensters[b].rand:=round(kont2diskFak('x',exprToFloat(sT,s)));
+ fensters[b].aktiv:=true;
continue;
end;
if istDasBefehl('Hintergrund abziehen',s,bekannteBefehle,false) then begin
@@ -3540,18 +3558,18 @@ begin
exit;
until false;
bekannteBefehle.free;
- Fensters[true].Breite:=_tsiz-Fensters[true].Breite;
- Fensters[false].Breite:=_xsteps-Fensters[false].Breite;
+ fensters[true].breite:=_tSiz-fensters[true].breite;
+ fensters[false].breite:=_xSteps-fensters[false].breite;
- if st then begin
+ if sT then begin
for b:=false to true do
- Fensters[b].free;
+ fensters[b].free;
result:=true;
exit;
end;
if hintergrundAbziehen then
- case Genauigkeit of
+ case genauigkeit of
gSingle:
hintergrund:=sWerte.ermittleHintergrund;
gDouble:
@@ -3561,15 +3579,15 @@ begin
end{of case};
gibAus('Threads starten',3);
- setlength(fensterThreads,threads);
+ setLength(fensterThreads,threads);
for i:=0 to length(fensterThreads)-1 do
fensterThreads[i]:=
tFensterThread.create(
self,
- round(i/length(fensterThreads)*_xsteps),
- round((i+1)/length(fensterThreads)*_xsteps-1),
+ round(i/length(fensterThreads)*_xSteps),
+ round((i+1)/length(fensterThreads)*_xSteps-1),
0,
- _tsiz-1,
+ _tSiz-1,
fensters[false],
fensters[true],
hintergrund);
@@ -3584,10 +3602,10 @@ begin
result:=true;
end;
-function tWerte.extrahiereEinhuellende(st: boolean; f: tMyStringlist; threads: longint; Warn: tWarnstufe): boolean;
+function tWerte.extrahiereEinhuellende(sT: boolean; f: tMyStringList; threads: longint; Warn: tWarnstufe): boolean;
var
Zeit,pvFehler,hintergrund,xFak,yFak: extended;
- Fensters: array[boolean] of tSin2Fenster;
+ fensters: array[boolean] of tSin2Fenster;
s: string;
b,hintergrundAbziehen: boolean;
betraege: tWerte;
@@ -3595,10 +3613,10 @@ var
begin
result:=false;
Zeit:=now;
- if not st then
+ if not sT then
gibAus('Einhüllende extrahieren ...',3);
for b:=false to true do
- Fensters[b]:=tSin2Fenster.create;
+ fensters[b]:=tSin2Fenster.create;
hintergrundAbziehen:=false;
hintergrund:=0;
xFak:=1;
@@ -3607,6 +3625,8 @@ begin
repeat
if not f.metaReadln(s,true) then begin
gibAus('Unerwartetes Dateiende!',3);
+ for b:=false to true do
+ fensters[b].free;
exit;
end;
bekannteBefehle.clear;
@@ -3617,9 +3637,9 @@ begin
b:=s[1]='t';
delete(s,1,pos(':',s));
s:=trim(s);
- if b then Fensters[b].Rand:=round(kont2diskFak('t',exprtofloat(st,s)))
- else Fensters[b].Rand:=round(kont2diskFak('x',exprtofloat(st,s)));
- Fensters[b].aktiv:=true;
+ if b then fensters[b].rand:=round(kont2diskFak('t',exprToFloat(sT,s)))
+ else fensters[b].rand:=round(kont2diskFak('x',exprToFloat(sT,s)));
+ fensters[b].aktiv:=true;
continue;
end;
if istDasBefehl('Hintergrund abziehen',s,bekannteBefehle,false) then begin
@@ -3627,8 +3647,8 @@ begin
continue;
end;
if istDasBefehl('Abstandsmetrik',s,bekannteBefehle,true) then begin
- xFak:=round(kont2diskFak('x',exprtofloat(st,erstesArgument(s))));
- yFak:=round(kont2diskFak('t',exprtofloat(st,s)));
+ xFak:=round(kont2diskFak('x',exprToFloat(sT,erstesArgument(s))));
+ yFak:=round(kont2diskFak('t',exprToFloat(sT,s)));
end;
bekannteBefehle.sort;
gibAus('Verstehe Option '''+s+''' nicht beim Extrahieren der Einhüllenden!'#10'Ich kenne:'#10+bekannteBefehle.text,3);
@@ -3636,18 +3656,18 @@ begin
exit;
until false;
bekannteBefehle.free;
- Fensters[true].Breite:=_tsiz-Fensters[true].Breite;
- Fensters[false].Breite:=_xsteps-Fensters[false].Breite;
+ fensters[true].breite:=_tSiz-fensters[true].breite;
+ fensters[false].breite:=_xSteps-fensters[false].breite;
- if st then begin
+ if sT then begin
for b:=false to true do
- Fensters[b].free;
+ fensters[b].free;
result:=true;
exit;
end;
if hintergrundAbziehen then
- case Genauigkeit of
+ case genauigkeit of
gSingle:
hintergrund:=sWerte.ermittleHintergrund;
gDouble:
@@ -3657,32 +3677,32 @@ begin
end{of case};
gibAus('berechne t-FFT ...',3);
- if not fft(threads,true,false,doRes,doResSmi,Fensters[true],hintergrund,pvFehler,Warn) then begin
+ if not fft(threads,true,false,doRes,doResSmi,fensters[true],hintergrund,pvFehler,Warn) then begin
gibAus('Es traten Fehler auf!',3);
exit;
end;
- gibAus(' (Parseval-Fehler = '+floattostr(pvFehler)+')',3);
+ gibAus(' (Parseval-Fehler = '+floatToStr(pvFehler)+')',3);
gibAus('berechne x-FFT ...',3);
- if not fft(threads,false,false,doRes,doResSmi,Fensters[false],0,pvFehler,Warn) then begin
+ if not fft(threads,false,false,doRes,doResSmi,fensters[false],0,pvFehler,Warn) then begin
gibAus('Es traten Fehler auf!',3);
exit;
end;
- gibAus(' (Parseval-Fehler = '+floattostr(pvFehler)+')',3);
+ gibAus(' (Parseval-Fehler = '+floatToStr(pvFehler)+')',3);
for b:=false to true do
- Fensters[b].free;
+ fensters[b].free;
gibAus('spektrale Beträge ermitteln',3);
- betraege:=tWerte.create(self,0,_xsteps-1);
+ betraege:=tWerte.create(self,0,_xSteps-1);
betraege.fft2dNachbearbeitung(threads,doBetrQdr);
gibAus('hohe Frequenzen filtern',3);
- case Genauigkeit of
+ case genauigkeit of
gSingle:
- sWerte.filtereHoheFrequenzen(betraege.sWerte,xFak,yFak);
+ sWerte.kantenFilter(betraege.sWerte,xFak,yFak,kfTiefpass);
gDouble:
- dWerte.filtereHoheFrequenzen(betraege.dWerte,xFak,yFak);
+ dWerte.kantenFilter(betraege.dWerte,xFak,yFak,kfTiefpass);
gExtended:
- eWerte.filtereHoheFrequenzen(betraege.eWerte,xFak,yFak);
+ eWerte.kantenFilter(betraege.eWerte,xFak,yFak,kfTiefpass);
end{of case};
betraege.free;
@@ -3691,20 +3711,143 @@ begin
gibAus('Es traten Fehler auf!',3);
exit;
end;
- gibAus(' (Parseval-Fehler = '+floattostr(pvFehler)+')',3);
+ gibAus(' (Parseval-Fehler = '+floatToStr(pvFehler)+')',3);
+ gibAus('berechne inverse t-FFT ...',3);
+ if not fft(threads,true,true,doResSmi,doBetr,nil,hintergrund,pvFehler,Warn) then begin
+ gibAus('Es traten Fehler auf!',3);
+ exit;
+ end;
+ gibAus(' (Parseval-Fehler = '+floatToStr(pvFehler)+')',3);
+ gibAus('... fertig '+timetostr(now-Zeit),3);
+ result:=true;
+end;
+
+function tWerte.extrahierePhase(sT: boolean; f: tMyStringList; threads: longint; Warn: tWarnstufe): boolean;
+var
+ Zeit,pvFehler,hintergrund,xFak,yFak: extended;
+ fensters: array[boolean] of tSin2Fenster;
+ s: string;
+ b,hintergrundAbziehen: boolean;
+ bekannteBefehle: tMyStringList;
+ maxPos: tIntPoint;
+ betraege: tWerte;
+begin
+ result:=false;
+ Zeit:=now;
+ if not sT then
+ gibAus('Phase extrahieren ...',3);
+ for b:=false to true do
+ fensters[b]:=tSin2Fenster.create;
+ hintergrundAbziehen:=false;
+ hintergrund:=0;
+ xFak:=1;
+ yFak:=1;
+ bekannteBefehle:=tMyStringList.create;
+ repeat
+ if not f.metaReadln(s,true) then begin
+ gibAus('Unerwartetes Dateiende!',3);
+ for b:=false to true do
+ fensters[b].free;
+ exit;
+ end;
+ bekannteBefehle.clear;
+ if istDasBefehl('Ende',s,bekannteBefehle,false) then break;
+ bekannteBefehle.add('''x-Fenster: ...''');
+ bekannteBefehle.add('''t-Fenster: ...''');
+ if (pos('-Fenster:',s)=2) and (s[1] in ['x','t']) then begin
+ b:=s[1]='t';
+ delete(s,1,pos(':',s));
+ s:=trim(s);
+ if b then fensters[b].rand:=round(kont2diskFak('t',exprToFloat(sT,s)))
+ else fensters[b].rand:=round(kont2diskFak('x',exprToFloat(sT,s)));
+ fensters[b].aktiv:=true;
+ continue;
+ end;
+ if istDasBefehl('Hintergrund abziehen',s,bekannteBefehle,false) then begin
+ hintergrundAbziehen:=true;
+ continue;
+ end;
+ if istDasBefehl('Abstandsmetrik',s,bekannteBefehle,true) then begin
+ xFak:=round(kont2diskFak('x',exprToFloat(sT,erstesArgument(s))));
+ yFak:=round(kont2diskFak('t',exprToFloat(sT,s)));
+ end;
+ bekannteBefehle.sort;
+ gibAus('Verstehe Option '''+s+''' nicht beim Extrahieren der Phase!'#10'Ich kenne:'#10+bekannteBefehle.text,3);
+ bekannteBefehle.free;
+ exit;
+ until false;
+ bekannteBefehle.free;
+ fensters[true].breite:=_tSiz-fensters[true].breite;
+ fensters[false].breite:=_xSteps-fensters[false].breite;
+
+ if sT then begin
+ for b:=false to true do
+ fensters[b].free;
+ result:=true;
+ exit;
+ end;
+
+ if hintergrundAbziehen then
+ case genauigkeit of
+ gSingle:
+ hintergrund:=sWerte.ermittleHintergrund;
+ gDouble:
+ hintergrund:=dWerte.ermittleHintergrund;
+ gExtended:
+ hintergrund:=eWerte.ermittleHintergrund;
+ end{of case};
+
+ gibAus('berechne t-FFT ...',3);
+ if not fft(threads,true,false,doRes,doResSmi,fensters[true],hintergrund,pvFehler,Warn) then begin
+ gibAus('Es traten Fehler auf!',3);
+ exit;
+ end;
+ gibAus(' (Parseval-Fehler = '+floatToStr(pvFehler)+')',3);
+ gibAus('berechne x-FFT ...',3);
+ if not fft(threads,false,false,doRes,doResSmi,fensters[false],0,pvFehler,Warn) then begin
+ gibAus('Es traten Fehler auf!',3);
+ exit;
+ end;
+ gibAus(' (Parseval-Fehler = '+floatToStr(pvFehler)+')',3);
+ for b:=false to true do
+ fensters[b].free;
+
+ gibAus('spektrale Beträge ermitteln',3);
+ betraege:=tWerte.create(self,0,_xSteps-1);
+ betraege.fft2dNachbearbeitung(threads,doBetrQdr);
+
+ fft2dNachbearbeitung(threads,doAlleResIms);
+
+ gibAus('tiefe Frequenzen filtern',3);
+ case genauigkeit of
+ gSingle:
+ sWerte.kantenFilter(betraege.sWerte,xFak,yFak,kfHochpass,true,maxPos);
+ gDouble:
+ dWerte.kantenFilter(betraege.dWerte,xFak,yFak,kfHochpass,true,maxPos);
+ gExtended:
+ eWerte.kantenFilter(betraege.eWerte,xFak,yFak,kfHochpass,true,maxPos);
+ end{of case};
+ betraege.free;
+
+ gibAus('berechne inverse x-FFT ...',3);
+ if not fft(threads,false,true,doAlleResIms,doAlleResIms,nil,0,pvFehler,wsLasch) then begin
+ gibAus('Es traten Fehler auf!',3);
+ exit;
+ end;
+ gibAus(' (Parseval-Fehler = '+floatToStr(pvFehler)+')',3);
gibAus('berechne inverse t-FFT ...',3);
- if not fft(threads,true,true,doResSmi,doRes,nil,hintergrund,pvFehler,Warn) then begin
+ if not fft(threads,true,true,doAlleResIms,doAlleResIms,nil,hintergrund,pvFehler,Warn) then begin
gibAus('Es traten Fehler auf!',3);
exit;
end;
- gibAus(' (Parseval-Fehler = '+floattostr(pvFehler)+')',3);
+ gibAus(' (Parseval-Fehler = '+floatToStr(pvFehler)+')',3);
gibAus('... fertig '+timetostr(now-Zeit),3);
result:=true;
end;
-function tWerte.berechneIntegral(st: boolean; f: tMyStringlist; threads: longint; quelle: tWerte): boolean;
+function tWerte.berechneIntegral(sT: boolean; f: tMyStringList; threads: longint; quelle: tWerte): boolean;
var
- i,tmin,tmax,xmin,xmax: longint;
+ i,tMin,tMax,xMin,xMax: longint;
Zeit: extended;
s: string;
rtg: tIntegrationsRichtung;
@@ -3713,13 +3856,13 @@ var
bekannteBefehle: tMyStringList;
begin
result:=false;
- warteaufBeendigungDesLeseThreads;
+ warteAufBeendigungDesLeseThreads;
Zeit:=now;
- tmin:=0;
- tmax:=quelle._tsiz-1;
- xmin:=0;
- xmax:=quelle._xsteps-1;
- Genauigkeit:=gExtended;
+ tMin:=0;
+ tMax:=quelle._tSiz-1;
+ xMin:=0;
+ xMax:=quelle._xSteps-1;
+ genauigkeit:=gExtended;
rtg:=irHorizontal;
bekannteBefehle:=tMyStringList.create;
repeat
@@ -3734,20 +3877,20 @@ begin
threads:=strtoint(s);
continue;
end;
- if istDasBefehl('xmin:',s,bekannteBefehle,true) then begin
- xmin:=quelle.kont2disk('x',quelle.exprtofloat(st,s));
+ if istDasBefehl('xMin:',s,bekannteBefehle,true) then begin
+ xMin:=quelle.kont2disk('x',quelle.exprToFloat(sT,s));
continue;
end;
- if istDasBefehl('xmax:',s,bekannteBefehle,true) then begin
- xmax:=quelle.kont2disk('x',quelle.exprtofloat(st,s));
+ if istDasBefehl('xMax:',s,bekannteBefehle,true) then begin
+ xMax:=quelle.kont2disk('x',quelle.exprToFloat(sT,s));
continue;
end;
- if istDasBefehl('tmin:',s,bekannteBefehle,true) then begin
- tmin:=quelle.kont2disk('t',quelle.exprtofloat(st,s));
+ if istDasBefehl('tMin:',s,bekannteBefehle,true) then begin
+ tMin:=quelle.kont2disk('t',quelle.exprToFloat(sT,s));
continue;
end;
- if istDasBefehl('tmax:',s,bekannteBefehle,true) then begin
- tmax:=quelle.kont2disk('t',quelle.exprtofloat(st,s));
+ if istDasBefehl('tMax:',s,bekannteBefehle,true) then begin
+ tMax:=quelle.kont2disk('t',quelle.exprToFloat(sT,s));
continue;
end;
if istDasBefehl('Richtung:',s,bekannteBefehle,true) then begin
@@ -3775,29 +3918,29 @@ begin
exit;
until false;
bekannteBefehle.free;
- tmin:=max(0,tmin);
- tmax:=min(quelle._tsiz-1,tmax);
- xmin:=max(0,xmin);
- xmax:=min(quelle._xsteps-1,xmax);
- Transformationen:=tKoordinatenAusschnitt.create(quelle.Transformationen,xmin,xmax,tmin,tmax);
- if not st then begin
- _tsiz:=tmax-tmin+1;
- _xsteps:=xmax-xmin+1;
-
- eWerte.holeRam(3);
+ tMin:=max(0,tMin);
+ tMax:=min(quelle._tSiz-1,tMax);
+ xMin:=max(0,xMin);
+ xMax:=min(quelle._xSteps-1,xMax);
+ transformationen:=tKoordinatenAusschnitt.create(quelle.transformationen,xMin,xMax,tMin,tMax);
+ if not sT then begin
+ _tSiz:=tMax-tMin+1;
+ _xSteps:=xMax-xMin+1;
+
+ holeRAM(3);
gibAus('Berechne Integrale ...',3);
- setlength(intThreads,threads);
+ setLength(intThreads,threads);
for i:=0 to length(intThreads)-1 do
intThreads[i]:=
tIntegralThread.create(
quelle,
self,
- xmin,
- xmax,
- tmin+round( i /length(intThreads)*(tmax+1-tmin)),
- tmin+round((i+1)/length(intThreads)*(tmax+1-tmin)-1),
- xmin,
- tmin,
+ xMin,
+ xMax,
+ tMin+round( i /length(intThreads)*(tMax+1-tMin)),
+ tMin+round((i+1)/length(intThreads)*(tMax+1-tMin)-1),
+ xMin,
+ tMin,
rtg);
repeat
fertig:=true;
@@ -3814,41 +3957,41 @@ begin
result:=true;
end;
-function tWerte.berechneFFT(st: boolean; 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;
- Fenster: tSin2Fenster;
+ nB: tFFTDatenordnung;
+ fenster: tSin2Fenster;
senkrecht: boolean;
s: string;
bekannteBefehle: tMyStringList;
begin
result:=false;
- warteaufBeendigungDesLeseThreads;
+ warteAufBeendigungDesLeseThreads;
Zeit:=now;
- NB:=doBetrQdr;
- Fenster:=tSin2Fenster.create;
+ nB:=doBetrQdr;
+ fenster:=tSin2Fenster.create;
senkrecht:=true;
bekannteBefehle:=tMyStringList.create;
repeat
if not f.metaReadln(s,true) then begin
gibAus('Unerwartetes Dateiende!',3);
- Fenster.free;
+ fenster.free;
bekannteBefehle.free;
exit;
end;
bekannteBefehle.clear;
if istDasBefehl('Ende',s,bekannteBefehle,false) then break;
if istDasBefehl('Nachbereitung:',s,bekannteBefehle,true) then begin
- if not strToFftDo(NB,s) then exit;
+ if not strToFftDo(nB,s) then exit;
continue;
end;
if istDasBefehl('Fenster:',s,bekannteBefehle,true) then begin
if senkrecht then
- Fenster.Rand:=round(kont2diskFak('t',exprtofloat(st,s)))
+ fenster.rand:=round(kont2diskFak('t',exprToFloat(sT,s)))
else
- Fenster.Rand:=round(kont2diskFak('x',exprtofloat(st,s)));
- Fenster.aktiv:=true;
+ fenster.rand:=round(kont2diskFak('x',exprToFloat(sT,s)));
+ fenster.aktiv:=true;
continue;
end;
if istDasBefehl('senkrecht',s,bekannteBefehle,false) then begin
@@ -3861,62 +4004,62 @@ begin
end;
bekannteBefehle.sort;
gibAus('Verstehe Option '''+s+''' nicht bei Erstellung einer FFT!'#10'Ich kenne:'#10+bekannteBefehle.text,3);
- Fenster.free;
+ fenster.free;
bekannteBefehle.free;
exit;
until false;
bekannteBefehle.free;
if senkrecht then
- Fenster.Breite:=_tsiz - Fenster.Rand
+ fenster.breite:=_tSiz - fenster.rand
else
- Fenster.Breite:=_xsteps - Fenster.Rand;
- if not st then begin
+ fenster.breite:=_xSteps - fenster.rand;
+ if not sT then begin
gibAus('berechne FFT ...',3);
- if not fft(threads,senkrecht,false,doRes,NB,Fenster,0,pvFehler,Warn) then begin
+ if not fft(threads,senkrecht,false,doRes,nB,fenster,0,pvFehler,Warn) then begin
gibAus('Es traten Fehler auf!',3);
- Fenster.free;
+ fenster.free;
exit;
end;
- gibAus(' (Parseval-Fehler = '+floattostr(pvFehler)+')',3);
+ gibAus(' (Parseval-Fehler = '+floatToStr(pvFehler)+')',3);
end;
- Transformationen:=tFFTTransformation.create(Transformationen,not senkrecht,senkrecht);
- if not st then begin
- eWerte.holeRam(0);
+ transformationen:=tFFTTransformation.create(transformationen,not senkrecht,senkrecht);
+ if not sT then begin
+ holeRAM(0);
gibAus('... fertig! '+timetostr(now-Zeit),3);
end;
- Fenster.free;
+ fenster.free;
result:=true;
end;
-function tWerte.berechneFFT2d(st: boolean; 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;
- Fensters: array[boolean] of tSin2Fenster;
+ nB,preOrd: tFFTDatenordnung;
+ fensters: array[boolean] of tSin2Fenster;
s: string;
b,spiegeln: boolean;
bekannteBefehle: tMyStringList;
begin
result:=false;
- warteaufBeendigungDesLeseThreads;
+ warteAufBeendigungDesLeseThreads;
Zeit:=now;
- NB:=doBetrQdr;
+ nB:=doBetrQdr;
for b:=false to true do
- Fensters[b]:=tSin2Fenster.create;
+ fensters[b]:=tSin2Fenster.create;
spiegeln:=false;
bekannteBefehle:=tMyStringList.create;
repeat
if not f.metaReadln(s,true) then begin
gibAus('Unerwartetes Dateiende!',3);
for b:=false to true do
- Fensters[b].free;
+ fensters[b].free;
bekannteBefehle.free;
exit;
end;
bekannteBefehle.clear;
if istDasBefehl('Ende',s,bekannteBefehle,false) then break;
if istDasBefehl('Nachbereitung:',s,bekannteBefehle,true) then begin
- if not strToFftDo(NB,s) then exit;
+ if not strToFftDo(nB,s) then exit;
continue;
end;
bekannteBefehle.add('''x-Fenster: ...''');
@@ -3925,9 +4068,9 @@ begin
b:=s[1]='t';
delete(s,1,pos(':',s));
s:=trim(s);
- if b then Fensters[b].Rand:=round(kont2diskFak('t',exprtofloat(st,s)))
- else Fensters[b].Rand:=round(kont2diskFak('x',exprtofloat(st,s)));
- Fensters[b].aktiv:=true;
+ if b then fensters[b].rand:=round(kont2diskFak('t',exprToFloat(sT,s)))
+ else fensters[b].rand:=round(kont2diskFak('x',exprToFloat(sT,s)));
+ fensters[b].aktiv:=true;
continue;
end;
if istDasBefehl('x-Spiegelung',s,bekannteBefehle,false) then begin
@@ -3937,69 +4080,69 @@ begin
bekannteBefehle.sort;
gibAus('Verstehe Option '''+s+''' nicht bei Erstellung einer zweidimensionalen FFT!'#10'Ich kenne:'#10+bekannteBefehle.text,3);
for b:=false to true do
- Fensters[b].free;
+ fensters[b].free;
bekannteBefehle.free;
exit;
until false;
bekannteBefehle.free;
- Fensters[true].Breite:=_tsiz-Fensters[true].Breite;
- Fensters[false].Breite:=_xsteps-Fensters[false].Breite;
- if NB=doResIms then preOrd:=doResIms
+ fensters[true].breite:=_tSiz-fensters[true].breite;
+ fensters[false].breite:=_xSteps-fensters[false].breite;
+ if nB=doResIms then preOrd:=doResIms
else preOrd:=doResSmi;
- if st then begin
+ if sT then begin
result:=true;
for b:=false to true do
- Fensters[b].free;
+ fensters[b].free;
exit;
end;
- Transformationen:=tFFTTransformation.create(Transformationen,true,true);
+ transformationen:=tFFTTransformation.create(transformationen,true,true);
if spiegeln then begin
gibAus('Werte spiegeln ...',3);
spiegle(threads);
gibAus('... fertig! '+timetostr(now-Zeit),3);
end;
gibAus('berechne t-FFT ...',3);
- if not fft(threads,true,false,doRes,preOrd,Fensters[true],0,pvFehler,Warn) then begin
+ if not fft(threads,true,false,doRes,preOrd,fensters[true],0,pvFehler,Warn) then begin
gibAus('Es traten Fehler auf!',3);
exit;
end;
- gibAus(' (Parseval-Fehler = '+floattostr(pvFehler)+')',3);
+ gibAus(' (Parseval-Fehler = '+floatToStr(pvFehler)+')',3);
gibAus('... fertig! '+timetostr(now-Zeit),3);
gibAus('berechne x-FFT ...',3);
- if not fft(threads,false,false,doRes,preOrd,Fensters[false],0,pvFehler,Warn) then begin
+ if not fft(threads,false,false,doRes,preOrd,fensters[false],0,pvFehler,Warn) then begin
gibAus('Es traten Fehler auf!',3);
exit;
end;
- gibAus(' (Parseval-Fehler = '+floattostr(pvFehler)+')',3);
+ gibAus(' (Parseval-Fehler = '+floatToStr(pvFehler)+')',3);
gibAus('... fertig! '+timetostr(now-Zeit),3);
gibAus('Wertenachbearbeiten ...',3);
- case NB of
+ case nB of
doBetr,doBetrQdr:
- fft2dNachbearbeitung(threads,nb);
+ fft2dNachbearbeitung(threads,nB);
end{of case};
gibAus('... fertig! '+timetostr(now-Zeit),3);
for b:=false to true do
- Fensters[b].free;
+ fensters[b].free;
result:=true;
end;
-function tWerte.erzeugeLinearesBild(st: boolean; var f: tMyStringlist; maxThreads: longint): boolean;
+function tWerte.erzeugeLinearesBild(sT: boolean; var f: tMyStringList; maxThreads: longint): boolean;
var
s,datei: string;
i,j,k,schriftgroesze: longint;
- xzoom,yzoom,wert,schritt,miw,maw,Zeit,
+ xZoom,yZoom,wert,schritt,miW,maW,Zeit,
xp0,tp0: extended;
- xmin,xmax,tmin,tmax,xp,tp,
- breite,hoehe,lof,rof,oof,uof: longint;
- Paletten: pTPalettenArray;
- Nachbearbeitungen: tTransformationArray;
+ xMin,xMax,tMin,tMax,xp,tp,
+ breite,hoehe,lOf,rOf,oOf,uOf: longint;
+ paletten: pTPalettenArray;
+ nachbearbeitungen: tTransformationArray;
Ausschnitt: tTransformation;
- BilderThreads: array of TBilderthread;
- fertig,Rahmen: boolean;
+ bilderThreads: array of tBilderThread;
+ fertig,rahmen,komplex: boolean;
img: file;
- Achsen: array of TAchse;
+ achsen: array of tAchse;
fontRenderer: tFontRenderer;
beschriftungen: array of tBeschriftung;
verwKonturen: array of tZuZeichnendeKontur;
@@ -4011,56 +4154,57 @@ procedure aufraeumen;
var
ii: longint;
begin
- for ii:=0 to length(Nachbearbeitungen)-1 do
- zerstoereTransformationWennObsolet(Nachbearbeitungen[ii]);
- setlength(Nachbearbeitungen,0);
+ for ii:=0 to length(nachbearbeitungen)-1 do
+ zerstoereTransformationWennObsolet(nachbearbeitungen[ii]);
+ setLength(nachbearbeitungen,0);
Ausschnitt.free;
Ausschnitt:=nil;
- for ii:=0 to length(BilderThreads)-1 do
- if assigned(BilderThreads[ii]) then
- BilderThreads[ii].free;
- setlength(BilderThreads,0);
+ for ii:=0 to length(bilderThreads)-1 do
+ if assigned(bilderThreads[ii]) then
+ bilderThreads[ii].free;
+ setLength(bilderThreads,0);
for ii:=0 to length(beschriftungen)-1 do
if assigned(beschriftungen[ii]) then
beschriftungen[ii].free;
- setlength(beschriftungen,0);
- setlength(Achsen,0);
+ setLength(beschriftungen,0);
+ setLength(achsen,0);
if assigned(fontRenderer) then
fontRenderer.free;
for ii:=0 to length(verwKonturen)-1 do
verwKonturen[ii].free;
- setlength(verwKonturen,0);
+ setLength(verwKonturen,0);
musterKontur.free;
bekannteBefehle.free;
end;
begin
result:=false;
- warteaufBeendigungDesLeseThreads;
+ warteAufBeendigungDesLeseThreads;
Zeit:=now;
- if not st then gibAus('erzeuge lineares Bild aus '+bezeichner+' ...',3);
+ if not sT then gibAus('erzeuge lineares Bild aus '+bezeichner+' ...',3);
datei:='';
- xzoom:=1;
- yzoom:=1;
- xmin:=0;
- xmax:=_xsteps-1;
- tmin:=0;
- tmax:=_tsiz-1;
+ xZoom:=1;
+ yZoom:=1;
+ xMin:=0;
+ xMax:=_xSteps-1;
+ tMin:=0;
+ tMax:=_tSiz-1;
schriftgroesze:=24;
- setlength(quellen,1);
+ setLength(quellen,1);
quellen[0]:=self;
- setlength(Nachbearbeitungen,1);
- Nachbearbeitungen[0]:=tKeineTransformation.create;
- setlength(Paletten,1);
- findePalette(Paletten[0],'Graustufen');
- setlength(Achsen,0);
- setlength(verwKonturen,0);
+ setLength(nachbearbeitungen,1);
+ nachbearbeitungen[0]:=tKeineTransformation.create;
+ setLength(paletten,1);
+ findePalette(paletten[0],'Graustufen');
+ setLength(achsen,0);
+ setLength(verwKonturen,0);
musterKontur:=tZuZeichnendeKontur.create;
- setlength(beschriftungen,0);
- setlength(BilderThreads,0);
+ setLength(beschriftungen,0);
+ setLength(bilderThreads,0);
Ausschnitt:=nil;
- Rahmen:=false;
+ rahmen:=false;
fontRenderer:=nil;
+ komplex:=false;
bekannteBefehle:=tMyStringList.create;
repeat
if not f.metaReadln(s,true) then begin
@@ -4074,33 +4218,33 @@ begin
continue;
end;
if istDasBefehl('Vergrößerung:',s,bekannteBefehle,true) then begin
- xzoom:=exprtofloat(st,s);
- yzoom:=exprtofloat(st,s);
+ xZoom:=exprToFloat(sT,s);
+ yZoom:=exprToFloat(sT,s);
continue;
end;
if istDasBefehl('x-Vergrößerung:',s,bekannteBefehle,true) then begin
- xzoom:=exprtofloat(st,s);
+ xZoom:=exprToFloat(sT,s);
continue;
end;
if istDasBefehl('t-Vergrößerung:',s,bekannteBefehle,true) then begin
- yzoom:=exprtofloat(st,s);
+ yZoom:=exprToFloat(sT,s);
continue;
end;
- if self.dichtenParameterErkannt(st,s,bekannteBefehle,maxThreads,xmin,xmax,tmin,tmax) then continue;
- if istDasBefehl('xmin:',s,bekannteBefehle,true) then begin
- xmin:=kont2disk('x',exprtofloat(st,s));
+ if self.dichtenParameterErkannt(sT,s,bekannteBefehle,maxThreads,xMin,xMax,tMin,tMax) then continue;
+ if istDasBefehl('xMin:',s,bekannteBefehle,true) then begin
+ xMin:=kont2disk('x',exprToFloat(sT,s));
continue;
end;
- if istDasBefehl('xmax:',s,bekannteBefehle,true) then begin
- xmax:=kont2disk('x',exprtofloat(st,s));
+ if istDasBefehl('xMax:',s,bekannteBefehle,true) then begin
+ xMax:=kont2disk('x',exprToFloat(sT,s));
continue;
end;
- if istDasBefehl('tmin:',s,bekannteBefehle,true) then begin
- tmin:=kont2disk('t',exprtofloat(st,s));
+ if istDasBefehl('tMin:',s,bekannteBefehle,true) then begin
+ tMin:=kont2disk('t',exprToFloat(sT,s));
continue;
end;
- if istDasBefehl('tmax:',s,bekannteBefehle,true) then begin
- tmax:=kont2disk('t',exprtofloat(st,s));
+ if istDasBefehl('tMax:',s,bekannteBefehle,true) then begin
+ tMax:=kont2disk('t',exprToFloat(sT,s));
continue;
end;
if istDasBefehl('Palette:',s,bekannteBefehle,true) then begin
@@ -4108,9 +4252,9 @@ begin
i:=strtoint(erstesArgument(s))
else
i:=0;
- if i>=length(Paletten) then
- setlength(Paletten,i+1);
- if not findePalette(Paletten[i],s) then begin
+ if i>=length(paletten) then
+ setLength(paletten,i+1);
+ if not findePalette(paletten[i],s) then begin
gibAus('Kenne Palette '''+s+''' nicht!',3);
aufraeumen;
exit;
@@ -4122,7 +4266,11 @@ begin
continue;
end;
if istDasBefehl('Rahmen',s,bekannteBefehle,false) then begin
- Rahmen:=true;
+ rahmen:=true;
+ continue;
+ end;
+ if istDasBefehl('komplex',s,bekannteBefehle,false) then begin
+ komplex:=true;
continue;
end;
if istDasBefehl('Nachbearbeitung:',s,bekannteBefehle,true) then begin
@@ -4132,13 +4280,13 @@ begin
i:=0;
if i>=length(nachbearbeitungen) then begin
j:=length(nachbearbeitungen);
- setlength(nachbearbeitungen,i+1);
+ setLength(nachbearbeitungen,i+1);
while j<length(nachbearbeitungen) do begin
nachbearbeitungen[j]:=tKeineTransformation.create;
inc(j);
end;
end;
- if not liesTWerteTransformationen(st,s,f,@exprtofloat,Nachbearbeitungen[i]) then begin
+ if not liesTWerteTransformationen(sT,s,f,@exprToFloat,nachbearbeitungen[i]) then begin
aufraeumen;
exit;
end;
@@ -4149,33 +4297,33 @@ begin
i:=strtoint(erstesArgument(s))
else
i:=0;
- if not erzeugeLegende(st,f,s,self,_minW,_maxW,Nachbearbeitungen[i],Paletten[i]) then begin
+ if not erzeugeLegende(sT,f,s,self,_minW,_maxW,nachbearbeitungen[i],paletten[i]) then begin
aufraeumen;
exit;
end;
continue;
end;
if istDasBefehl('Achse:',s,bekannteBefehle,true) then begin
- setlength(Achsen,length(Achsen)+1);
+ setLength(achsen,length(achsen)+1);
if startetMit('oben',s) then
- Achsen[length(Achsen)-1].Lage:=lOben
+ achsen[length(achsen)-1].lage:=lOben
else if startetMit('unten',s) then
- Achsen[length(Achsen)-1].Lage:=lUnten
+ achsen[length(achsen)-1].lage:=lUnten
else if startetMit('links',s) then
- Achsen[length(Achsen)-1].Lage:=lLinks
+ achsen[length(achsen)-1].lage:=lLinks
else if startetMit('rechts',s) then
- Achsen[length(Achsen)-1].Lage:=lRechts
+ achsen[length(achsen)-1].lage:=lRechts
else begin
gibAus('Ungültiger Parameter '''+s+''' für eine Achse!'#10'Ich kenne:'#10'''oben ...'''#10'''unten ...'''#10'''links ...'''#10'''rechts ...''',3);
aufraeumen;
exit;
end;
if endetMit('+',s) then
- Achsen[length(Achsen)-1].faktor:=1/2
+ achsen[length(achsen)-1].faktor:=1/2
else if endetMit('-',s) then
- Achsen[length(Achsen)-1].faktor:=2
- else Achsen[length(Achsen)-1].faktor:=1;
- Achsen[length(Achsen)-1].Striche:=strtoint(s);
+ achsen[length(achsen)-1].faktor:=2
+ else achsen[length(achsen)-1].faktor:=1;
+ achsen[length(achsen)-1].striche:=strtoint(s);
continue;
end;
if istDasBefehl('Konturen:',s,bekannteBefehle,false) then begin
@@ -4187,11 +4335,11 @@ begin
if s='Ende' then
break;
if startetMit('Dicke:',s) then begin
- musterKontur.dicke:=exprToFloat(st,s);
+ musterKontur.dicke:=exprToFloat(sT,s);
continue;
end;
if startetMit('Deckkraft:',s) then begin
- musterKontur.deckKraft:=exprToFloat(st,s);
+ musterKontur.deckKraft:=exprToFloat(sT,s);
continue;
end;
if startetMit('Farbe:',s) then begin
@@ -4200,14 +4348,14 @@ begin
exit;
end;
while s<>'' do begin
- setlength(verwKonturen,length(verwKonturen)+1);
- i:=findeKontur(erstesArgument(s),nil,Wertes,Konturen,false);
- if (i<0) or (i>=length(Konturen^)) then begin
+ setLength(verwKonturen,length(verwKonturen)+1);
+ i:=findeKontur(erstesArgument(s),nil,wertes,konturen,false);
+ if (i<0) or (i>=length(konturen^)) then begin
gibAus('Die Kontur '''+s+''' gibt es nicht!',3);
aufraeumen;
exit;
end;
- verwKonturen[length(verwKonturen)-1]:=tZuZeichnendeKontur.create(musterKontur,Konturen^[i]);
+ verwKonturen[length(verwKonturen)-1]:=tZuZeichnendeKontur.create(musterKontur,konturen^[i]);
end;
until false;
continue;
@@ -4216,14 +4364,14 @@ begin
i:=strtoint(erstesArgument(s));
if i>=length(quellen) then begin
j:=length(quellen);
- setlength(quellen,i+1);
+ setLength(quellen,i+1);
while j<length(quellen) do begin
quellen[j]:=nil;
inc(j);
end;
end;
if assigned(quellen[i]) then begin
- gibAus('Ich habe auf Position '+inttostr(i)+' schon eine Quelle fürs Bild!',3);
+ gibAus('Ich habe auf Position '+intToStr(i)+' schon eine Quelle fürs Bild!',3);
aufraeumen;
exit;
end;
@@ -4242,17 +4390,17 @@ begin
exit;
until false;
- if (length(Paletten)<>length(Quellen)) or
- (length(Nachbearbeitungen)<>length(Quellen)) then begin
+ if (length(paletten)<>length(quellen)) or
+ (length(nachbearbeitungen)<>length(quellen)) then begin
gibAus(
- 'Die Anzahl der Paletten ('+inttostr(length(Paletten))+'), '+
- 'der Daten ('+inttostr(length(Quellen))+') und '+
- 'der Nachbearbeitungen ('+inttostr(length(nachbearbeitungen))+') stimmen nicht überein!',3);
+ 'Die Anzahl der Paletten ('+intToStr(length(paletten))+'), '+
+ 'der Daten ('+intToStr(length(quellen))+') und '+
+ 'der Nachbearbeitungen ('+intToStr(length(nachbearbeitungen))+') stimmen nicht überein!',3);
aufraeumen;
exit;
end;
- if st then begin
+ if sT then begin
result:=true;
aufraeumen;
exit;
@@ -4263,116 +4411,116 @@ begin
aufraeumen;
exit;
end;
- xmin:=max(xmin,0);
- xmax:=min(xmax,_xsteps-1);
- tmin:=max(tmin,0);
- tmax:=min(tmax,_tsiz-1);
- gibAus('('+inttostr(xmin)+'-'+inttostr(xmax)+'x'+inttostr(tmin)+'-'+inttostr(tmax)+')',3);
- gibAus(' ('+floattostr(Transformationen.xstart)+'-'+floattostr(Transformationen.xstop)+' x '+floattostr(Transformationen.tstart)+'-'+floattostr(Transformationen.tstop)+')',3);
- breite:=round((xmax-xmin+1)*xzoom);
- hoehe:=round((tmax-tmin+1)*yzoom);
+ xMin:=max(xMin,0);
+ xMax:=min(xMax,_xSteps-1);
+ tMin:=max(tMin,0);
+ tMax:=min(tMax,_tSiz div (1+byte(komplex))-1);
+ gibAus('('+intToStr(xMin)+'-'+intToStr(xMax)+'x'+intToStr(tMin)+'-'+intToStr(tMax)+')',3);
+ gibAus(' ('+floatToStr(transformationen.xStart)+'-'+floatToStr(transformationen.xStop)+' x '+floatToStr(transformationen.tStart)+'-'+floatToStr(transformationen.tStop)+')',3);
+ breite:=round((xMax-xMin+1)*xZoom);
+ hoehe:=round((tMax-tMin+1)*yZoom);
- Ausschnitt:=tKoordinatenAusschnitt.create(Transformationen,xmin,xmax,tmin,tmax);
+ Ausschnitt:=tKoordinatenAusschnitt.create(transformationen,xMin,xMax,tMin,tMax);
if (breite=1) or (hoehe=1) then begin
gibAus('Keine/kaum Bildpunkte innerhalb der festgelegten Grenzen!',3);
aufraeumen;
exit;
end;
- gibAus(inttostr(breite)+' x '+inttostr(hoehe)+' Pixel',3);
+ gibAus(intToStr(breite)+' x '+intToStr(hoehe)+' Pixel',3);
fontRenderer:=tFontRenderer.create(schriftgroesze);
- setlength(Beschriftungen,0);
- for i:=0 to length(Achsen)-1 do begin
- if Achsen[i].Lage in [lOben,lUnten] then begin
- miw:=Ausschnitt.achsen['x','x'];
- maw:=Ausschnitt.achsen['x','y'];
+ setLength(beschriftungen,0);
+ for i:=0 to length(achsen)-1 do begin
+ if achsen[i].lage in [lOben,lUnten] then begin
+ miW:=Ausschnitt.achsen['x','x'];
+ maW:=Ausschnitt.achsen['x','y'];
end
else begin
- miw:=Ausschnitt.achsen['y','x'];
- maw:=Ausschnitt.achsen['y','y'];
+ miW:=Ausschnitt.achsen['y','x'];
+ maW:=Ausschnitt.achsen['y','y'];
end;
- schritt:=(maw-miw)/Achsen[i].Striche;
+ schritt:=(maW-miW)/achsen[i].striche;
j:=round(ln(schritt)/ln(10));
- schritt:=Achsen[i].faktor*power(10,j);
- wert:=ceil(miw/schritt)*schritt;
- while wert<=maw do begin
- setlength(beschriftungen,length(beschriftungen)+1);
+ schritt:=achsen[i].faktor*power(10,j);
+ wert:=ceil(miW/schritt)*schritt;
+ while wert<=maW do begin
+ setLength(beschriftungen,length(beschriftungen)+1);
beschriftungen[length(beschriftungen)-1]:=tBeschriftung.create;
- beschriftungen[length(beschriftungen)-1].bBreite:=Breite;
- beschriftungen[length(beschriftungen)-1].bHoehe:=Hoehe;
- beschriftungen[length(beschriftungen)-1].Rahmen:=Rahmen;
+ beschriftungen[length(beschriftungen)-1].bBreite:=breite;
+ beschriftungen[length(beschriftungen)-1].bHoehe:=hoehe;
+ beschriftungen[length(beschriftungen)-1].rahmen:=rahmen;
with beschriftungen[length(beschriftungen)-1] do begin
fontRend:=fontRenderer;
- lage:=Achsen[i].lage;
-// position:=(wert-miw)/(maw-miw);
- position:=Ausschnitt.wertZuPositionAufAchse(Achsen[i].Lage,wert);
+ lage:=achsen[i].lage;
+// position:=(wert-miW)/(maW-miW);
+ position:=Ausschnitt.wertZuPositionAufAchse(achsen[i].lage,wert);
if (position<0) or (position>1) then begin
- gibAus('Der Wert '+floattostr(wert)+' liegt außerhalb des Bildes ('+floattostr(position)+') - das sollte eigentlich nicht passieren!',3);
+ gibAus('Der Wert '+floatToStr(wert)+' liegt außerhalb des Bildes ('+floatToStr(position)+') - das sollte eigentlich nicht passieren!',3);
beschriftungen[length(beschriftungen)-1].free;
- setlength(beschriftungen,length(beschriftungen)-1);
+ setLength(beschriftungen,length(beschriftungen)-1);
aufraeumen;
exit;
end
else begin
if lage in [lOben,lUnten] then position:=position*bBreite
else position:=position*bHoehe;
- inhalt:=floattostr(wert);
+ inhalt:=floatToStr(wert);
end;
end;
wert:=wert+schritt;
end;
end;
- gibAus(inttostr(length(Beschriftungen))+' Zahlen an den Achsen',3);
- lof:=Byte(Rahmen);
- rof:=Byte(Rahmen);
- oof:=Byte(Rahmen);
- uof:=Byte(Rahmen);
+ gibAus(intToStr(length(beschriftungen))+' Zahlen an den Achsen',3);
+ lOf:=byte(rahmen);
+ rOf:=byte(rahmen);
+ oOf:=byte(rahmen);
+ uOf:=byte(rahmen);
for i:=0 to length(beschriftungen)-1 do
- with Beschriftungen[i] do begin
- lof:=max(lof,-links);
- rof:=max(rof,1+rechts-bBreite);
- oof:=max(oof,-oben);
- uof:=max(uof,1+unten-bHoehe);
- end;
- if lof+oof+rof+uof>0 then
- gibAus('Extra-Ränder: '+inttostr(lof)+' Pixel links, '+inttostr(oof)+' Pixel oben, '+inttostr(rof)+' Pixel rechts und '+inttostr(uof)+' Pixel unten.',3);
-
- setlength(Bilderthreads,maxThreads);
- for i:=0 to length(Bilderthreads)-1 do
- Bilderthreads[i]:=tBilderthread.create(i,length(Bilderthreads),breite,hoehe,lof,oof,rof,uof,quellen,xmin,xmax,tmin,tmax,xzoom,yzoom,Nachbearbeitungen,paletten,@Beschriftungen,rahmen);
- for i:=0 to length(Bilderthreads)-1 do begin
- gibAus('starte Thread '+inttostr(i)+' ...',1);
- Bilderthreads[i].suspended:=false;
+ with beschriftungen[i] do begin
+ lOf:=max(lOf,-links);
+ rOf:=max(rOf,1+rechts-bBreite);
+ oOf:=max(oOf,-oben);
+ uOf:=max(uOf,1+unten-bHoehe);
+ end;
+ if lOf+oOf+rOf+uOf>0 then
+ gibAus('Extra-Ränder: '+intToStr(lOf)+' Pixel links, '+intToStr(oOf)+' Pixel oben, '+intToStr(rOf)+' Pixel rechts und '+intToStr(uOf)+' Pixel unten.',3);
+
+ setLength(bilderThreads,maxThreads);
+ for i:=0 to length(bilderThreads)-1 do
+ bilderThreads[i]:=tBilderThread.create(i,length(bilderThreads),breite,hoehe,lOf,oOf,rOf,uOf,quellen,xMin,xMax,tMin,tMax,xZoom,yZoom,nachbearbeitungen,paletten,@beschriftungen,rahmen);
+ for i:=0 to length(bilderThreads)-1 do begin
+ gibAus('starte Thread '+intToStr(i)+' ...',1);
+ bilderThreads[i].suspended:=false;
gibAus('... ok!',1);
end;
repeat
sleep(10);
fertig:=true;
- for i:=0 to length(Bilderthreads)-1 do
- fertig:=fertig and Bilderthreads[i].fertig;
+ for i:=0 to length(bilderThreads)-1 do
+ fertig:=fertig and bilderThreads[i].fertig;
until fertig;
gibAus('Alle Threads beendet, Konturen einfügen ...',1);
for i:=0 to length(verwKonturen)-1 do begin
- for j:=0 to length(BilderThreads)-1 do
+ for j:=0 to length(bilderThreads)-1 do
bilderThreads[j].initAnzahlensFuerKontur;
for j:=0 to length(verwKonturen[i].kontur.orte)-1 do begin
- xp0:=(kont2diskFak('x',verwKonturen[i].kontur.orte[j]['x'])-xmin)*xzoom;
- tp0:=(kont2diskFak('t',verwKonturen[i].kontur.orte[j]['y'])-tmin)*yzoom;
+ xp0:=(kont2diskFak('x',verwKonturen[i].kontur.orte[j]['x'])-xMin)*xZoom;
+ tp0:=(kont2diskFak('t',verwKonturen[i].kontur.orte[j]['y'])-tMin)*yZoom;
for xp:=ceil(xp0-verwKonturen[i].dicke/2) to floor(xp0+verwKonturen[i].dicke/2) do
for tp:=ceil(tp0-verwKonturen[i].dicke/2) to floor(tp0+verwKonturen[i].dicke/2) do
- if (0<=xp) and (xp<Breite) and (0<=tp) and (tp<Hoehe) and (sqr(xp-xp0)+sqr(tp-tp0)<=sqr(verwKonturen[i].dicke/2)) then begin
+ if (0<=xp) and (xp<breite) and (0<=tp) and (tp<hoehe) and (sqr(xp-xp0)+sqr(tp-tp0)<=sqr(verwKonturen[i].dicke/2)) then begin
k:=0;
- while (k<length(Bilderthreads)-1) and (xp>=Bilderthreads[k+1].xpmi) do
+ while (k<length(bilderThreads)-1) and (xp>=bilderThreads[k+1].xPMi) do
inc(k);
- if Bilderthreads[k].anzahlens[0,(tp+oof)*Bilderthreads[k].Breite + xp - Bilderthreads[k].xpmi] = 0 then begin
- Bilderthreads[k].anzahlens[0,(tp+oof)*Bilderthreads[k].Breite + xp - Bilderthreads[k].xpmi]:=1;
- Bilderthreads[k].farben[(tp+oof)*Bilderthreads[k].Breite + xp - Bilderthreads[k].xpmi]:=
+ if bilderThreads[k].anzahlens[0,(tp+oOf)*bilderThreads[k].breite + xp - bilderThreads[k].xPMi] = 0 then begin
+ bilderThreads[k].anzahlens[0,(tp+oOf)*bilderThreads[k].breite + xp - bilderThreads[k].xPMi]:=1;
+ bilderThreads[k].farben[(tp+oOf)*bilderThreads[k].breite + xp - bilderThreads[k].xPMi]:=
mischeFarben(
- Bilderthreads[k].farben[(tp+oof)*Bilderthreads[k].Breite + xp - Bilderthreads[k].xpmi],
+ bilderThreads[k].farben[(tp+oOf)*bilderThreads[k].breite + xp - bilderThreads[k].xPMi],
verwKonturen[i].farbe,
verwKonturen[i].deckKraft
);
@@ -4383,12 +4531,12 @@ begin
gibAus('fertig, speichere Bild ...',1);
assign(img,datei);
rewrite(img,1);
- schreibeBmpHeader(img,breite+lof+rof,hoehe+oof+uof);
- for j:=-oof to uof+hoehe-1 do begin
- for i:=0 to length(Bilderthreads)-1 do
- blockwrite(img,Bilderthreads[i].farben[(j+oof)*Bilderthreads[i].Breite],3*Bilderthreads[i].Breite);
+ schreibeBmpHeader(img,breite+lOf+rOf,hoehe+oOf+uOf);
+ for j:=-oOf to uOf+hoehe-1 do begin
+ for i:=0 to length(bilderThreads)-1 do
+ blockwrite(img,bilderThreads[i].farben[(j+oOf)*bilderThreads[i].breite],3*bilderThreads[i].breite);
i:=0;
- blockwrite(img,i,(4-(((lof+breite+rof)*3) mod 4)) mod 4);
+ blockwrite(img,i,(4-(((lOf+breite+rOf)*3) mod 4)) mod 4);
end;
close(img);
gibAus('... Threads freigeben ...',1);
@@ -4398,25 +4546,25 @@ begin
gibAus('... fertig '+timetostr(now-Zeit),3);
end;
-function tWerte.erzeugeAscii(st: boolean; f: tMyStringlist): boolean;
+function tWerte.erzeugeAscii(sT: boolean; f: tMyStringList): boolean;
var
datei,s,separator: string;
- outf: textfile;
+ outF: textfile;
i,j: longint;
- xmin,xmax,tmin,tmax: longint;
+ xMin,xMax,tMin,tMax: longint;
Zeit: extended;
mitKoordinaten: byte;
bekannteBefehle: tMyStringList;
begin
result:=false;
- warteaufBeendigungDesLeseThreads;
+ warteAufBeendigungDesLeseThreads;
Zeit:=now;
gibAus('erzeuge Ascii-Datei ...',3);
datei:='';
- xmin:=0;
- xmax:=_xsteps-1;
- tmin:=0;
- tmax:=_tsiz-1;
+ xMin:=0;
+ xMax:=_xSteps-1;
+ tMin:=0;
+ tMax:=_tSiz-1;
mitKoordinaten:=0;
separator:=',';
bekannteBefehle:=tMyStringList.create;
@@ -4431,25 +4579,25 @@ begin
datei:=s;
continue;
end;
- if istDasBefehl('xmin:',s,bekannteBefehle,true) then begin
- xmin:=kont2disk('x',exprtofloat(st,s));
+ if istDasBefehl('xMin:',s,bekannteBefehle,true) then begin
+ xMin:=kont2disk('x',exprToFloat(sT,s));
continue;
end;
- if istDasBefehl('xmax:',s,bekannteBefehle,true) then begin
- xmax:=kont2disk('x',exprtofloat(st,s));
+ if istDasBefehl('xMax:',s,bekannteBefehle,true) then begin
+ xMax:=kont2disk('x',exprToFloat(sT,s));
continue;
end;
- if istDasBefehl('tmin:',s,bekannteBefehle,true) then begin
- tmin:=kont2disk('t',exprtofloat(st,s));
+ if istDasBefehl('tMin:',s,bekannteBefehle,true) then begin
+ tMin:=kont2disk('t',exprToFloat(sT,s));
continue;
end;
- if istDasBefehl('tmax:',s,bekannteBefehle,true) then begin
- tmax:=kont2disk('t',exprtofloat(st,s));
+ if istDasBefehl('tMax:',s,bekannteBefehle,true) then begin
+ tMax:=kont2disk('t',exprToFloat(sT,s));
continue;
end;
if istDasBefehl('Koordinaten einfügen',s,bekannteBefehle,false) then begin
- if (_xsteps=1) or (_tsiz=1) then begin
- mitKoordinaten:=byte(_xsteps=1)*2 + byte(_tsiz=1);
+ if (_xSteps=1) or (_tSiz=1) then begin
+ mitKoordinaten:=byte(_xSteps=1)*2 + byte(_tSiz=1);
continue;
end;
gibAus('Kann Koordinaten nicht in mehrdimensionale Daten einfügen!',3);
@@ -4458,14 +4606,14 @@ begin
end;
if istDasBefehl('Separator:',s,bekannteBefehle,true) then begin
if s='Leerzeichen' then begin
- Separator:=' ';
+ separator:=' ';
continue;
end;
if s='Tab' then begin
- Separator:=#9;
+ separator:=#9;
continue;
end;
- Separator:=s;
+ separator:=s;
continue;
end;
if istDasBefehl('Ende',s,bekannteBefehle,false) then break;
@@ -4476,81 +4624,81 @@ begin
until false;
bekannteBefehle.free;
- if st then begin
+ if sT then begin
result:=true;
exit;
end;
- assign(outf,datei);
- rewrite(outf);
+ assign(outF,datei);
+ rewrite(outF);
case mitKoordinaten of
0:
- case Genauigkeit of
+ case genauigkeit of
gSingle:
- for i:=max(0,tmin) to min(_tsiz-1,tmax) do begin
+ for i:=max(0,tMin) to min(_tSiz-1,tMax) do begin
s:='';
- for j:=max(0,xmin) to min(_xsteps-1,xmax) do
- s:=s+floattostr(sWerte.werte[i*_xsteps+j])+separator;
+ for j:=max(0,xMin) to min(_xSteps-1,xMax) do
+ s:=s+floatToStr(sWerte.werte[i*_xSteps+j])+separator;
delete(s,length(s),1);
- writeln(outf,s);
+ writeln(outF,s);
end;
gDouble:
- for i:=max(0,tmin) to min(_tsiz-1,tmax) do begin
+ for i:=max(0,tMin) to min(_tSiz-1,tMax) do begin
s:='';
- for j:=max(0,xmin) to min(_xsteps-1,xmax) do
- s:=s+floattostr(dWerte.werte[i*_xsteps+j])+separator;
+ for j:=max(0,xMin) to min(_xSteps-1,xMax) do
+ s:=s+floatToStr(dWerte.werte[i*_xSteps+j])+separator;
delete(s,length(s),1);
- writeln(outf,s);
+ writeln(outF,s);
end;
gExtended:
- for i:=max(0,tmin) to min(_tsiz-1,tmax) do begin
+ for i:=max(0,tMin) to min(_tSiz-1,tMax) do begin
s:='';
- for j:=max(0,xmin) to min(_xsteps-1,xmax) do
- s:=s+floattostr(eWerte.werte[i*_xsteps+j])+separator;
+ for j:=max(0,xMin) to min(_xSteps-1,xMax) do
+ s:=s+floatToStr(eWerte.werte[i*_xSteps+j])+separator;
delete(s,length(s),1);
- writeln(outf,s);
+ writeln(outF,s);
end;
end{of Case};
1:
- case Genauigkeit of
+ case genauigkeit of
gSingle:
- for i:=max(0,xmin) to min(_xsteps-1,xmax) do
- writeln(outf,floattostr(disk2kont('x',i))+separator+floattostr(sWerte.werte[i]));
+ for i:=max(0,xMin) to min(_xSteps-1,xMax) do
+ writeln(outF,floatToStr(disk2kont('x',i))+separator+floatToStr(sWerte.werte[i]));
gDouble:
- for i:=max(0,xmin) to min(_xsteps-1,xmax) do
- writeln(outf,floattostr(disk2kont('x',i))+separator+floattostr(dWerte.werte[i]));
+ for i:=max(0,xMin) to min(_xSteps-1,xMax) do
+ writeln(outF,floatToStr(disk2kont('x',i))+separator+floatToStr(dWerte.werte[i]));
gExtended:
- for i:=max(0,xmin) to min(_xsteps-1,xmax) do
- writeln(outf,floattostr(disk2kont('x',i))+separator+floattostr(eWerte.werte[i]));
+ for i:=max(0,xMin) to min(_xSteps-1,xMax) do
+ writeln(outF,floatToStr(disk2kont('x',i))+separator+floatToStr(eWerte.werte[i]));
end{of Case};
2:
- case Genauigkeit of
+ case genauigkeit of
gSingle:
- for i:=max(0,tmin) to min(_tsiz-1,tmax) do
- writeln(outf,floattostr(disk2kont('t',i))+separator+floattostr(sWerte.werte[i]));
+ for i:=max(0,tMin) to min(_tSiz-1,tMax) do
+ writeln(outF,floatToStr(disk2kont('t',i))+separator+floatToStr(sWerte.werte[i]));
gDouble:
- for i:=max(0,tmin) to min(_tsiz-1,tmax) do
- writeln(outf,floattostr(disk2kont('t',i))+separator+floattostr(dWerte.werte[i]));
+ for i:=max(0,tMin) to min(_tSiz-1,tMax) do
+ writeln(outF,floatToStr(disk2kont('t',i))+separator+floatToStr(dWerte.werte[i]));
gExtended:
- for i:=max(0,tmin) to min(_tsiz-1,tmax) do
- writeln(outf,floattostr(disk2kont('t',i))+separator+floattostr(eWerte.werte[i]));
+ for i:=max(0,tMin) to min(_tSiz-1,tMax) do
+ writeln(outF,floatToStr(disk2kont('t',i))+separator+floatToStr(eWerte.werte[i]));
end{of Case};
3:
- case Genauigkeit of
+ case genauigkeit of
gSingle:
- writeln(outf,floattostr(disk2kont('x',0))+separator+floattostr(disk2kont('t',0))+separator+floattostr(sWerte.werte[0]));
+ writeln(outF,floatToStr(disk2kont('x',0))+separator+floatToStr(disk2kont('t',0))+separator+floatToStr(sWerte.werte[0]));
gDouble:
- writeln(outf,floattostr(disk2kont('x',0))+separator+floattostr(disk2kont('t',0))+separator+floattostr(dWerte.werte[0]));
+ writeln(outF,floatToStr(disk2kont('x',0))+separator+floatToStr(disk2kont('t',0))+separator+floatToStr(dWerte.werte[0]));
gExtended:
- writeln(outf,floattostr(disk2kont('x',0))+separator+floattostr(disk2kont('t',0))+separator+floattostr(eWerte.werte[0]));
+ writeln(outF,floatToStr(disk2kont('x',0))+separator+floatToStr(disk2kont('t',0))+separator+floatToStr(eWerte.werte[0]));
end{of Case};
end{of Case};
- close(outf);
+ close(outF);
gibAus('... fertig '+timetostr(now-Zeit),3);
result:=true;
end;
-function tWerte.erzeugeLineout(st: boolean; params: string): boolean;
+function tWerte.erzeugeLineout(sT: boolean; params: string): boolean;
var
ab: array[boolean,boolean] of longint;
s: string;
@@ -4560,11 +4708,11 @@ var
b1,b2: boolean;
begin
result:=false;
- warteaufBeendigungDesLeseThreads;
+ warteAufBeendigungDesLeseThreads;
Zeit:=now;
- if not st then begin
+ if not sT then begin
gibAus('erzeuge Lineout ...',3);
- gibAus('insgesamt: '+floattostr(Transformationen.xstart)+'..'+floattostr(Transformationen.xstop)+' x '+floattostr(Transformationen.tstart)+'..'+floattostr(Transformationen.tstop),3);
+ gibAus('insgesamt: '+floatToStr(transformationen.xStart)+'..'+floatToStr(transformationen.xStop)+' x '+floatToStr(transformationen.tStart)+'..'+floatToStr(transformationen.tStop),3);
end;
for b1:=false to true do
@@ -4576,7 +4724,7 @@ begin
if startetMit('waagerecht',params) then b1:=true
else if startetMit('senkrecht',params) then b1:=false
else exit;
- if st then begin
+ if sT then begin
result:=true;
exit;
end;
@@ -4591,26 +4739,26 @@ begin
assignFile(f,params);
rewrite(f);
- for i:=0 to _xsteps*byte(not b1)+_tsiz*byte(b1)-1 do
+ for i:=0 to _xSteps*byte(not b1)+_tSiz*byte(b1)-1 do
schreibeWertIntegriert(f,i,b1);
- closefile(f);
+ closeFile(f);
end
else begin
for b1:=false to true do
if startetMit('(',params) then begin
s:=erstesArgument(params,',');
- ab[b1,false]:=kont2disk('x',exprtofloat(st,s));
+ ab[b1,false]:=kont2disk('x',exprToFloat(sT,s));
s:=erstesArgument(params,')');
- ab[b1,true]:=kont2disk('t',exprtofloat(st,s));
+ ab[b1,true]:=kont2disk('t',exprToFloat(sT,s));
end
else begin
ab[true,false]:=ab[false,false];
ab[true,true]:=ab[false,true];
- ab[false,false]:=(_xsteps-1)*byte(not b1);
- ab[false,true]:=(_tsiz-1)*byte(not b1);
+ ab[false,false]:=(_xSteps-1)*byte(not b1);
+ ab[false,true]:=(_tSiz-1)*byte(not b1);
end;
- if st then begin
+ if sT then begin
result:=true;
exit;
end;
@@ -4622,7 +4770,7 @@ begin
s:='... schreibe in '''+params+''' (';
for i:=0 to 3 do begin
- s:=s+inttostr(ab[odd(i div 2),odd(i)]);
+ s:=s+intToStr(ab[odd(i div 2),odd(i)]);
if not odd(i) then s:=s+','
else if i=1 then s:=s+')--(';
end;
@@ -4648,42 +4796,42 @@ begin
for i:=ab[false,false] downto ab[true,false] do
schreibeWert(f,i,round(ab[false,true]+i/(ab[true,false]-ab[false,false])*(ab[true,true]-ab[false,true])));
end;
- closefile(f);
+ closeFile(f);
end;
gibAus('... fertig '+timetostr(now-Zeit),3);
result:=true;
end;
-function tWerte.erzeugeBinning(st: boolean; params: string): boolean;
+function tWerte.erzeugeBinning(sT: boolean; params: string): boolean;
var
senkrecht,linien: boolean;
Zeit,x0,dx: extended;
begin
result:=false;
- warteaufBeendigungDesLeseThreads;
+ warteAufBeendigungDesLeseThreads;
Zeit:=now;
- if not st then begin
+ if not sT then begin
gibAus('erzeuge Binning ...',3);
- gibAus('insgesamt: '+floattostr(Transformationen.xstart)+'..'+floattostr(Transformationen.xstop)+' x '+floattostr(Transformationen.tstart)+'..'+floattostr(Transformationen.tstop),3);
+ gibAus('insgesamt: '+floatToStr(transformationen.xStart)+'..'+floatToStr(transformationen.xStop)+' x '+floatToStr(transformationen.tStart)+'..'+floatToStr(transformationen.tStop),3);
end;
- senkrecht:=Transformationen.xstart=Transformationen.xstop;
- if (not senkrecht) and (Transformationen.tstart<>Transformationen.tstop) then begin
+ senkrecht:=transformationen.xStart=transformationen.xStop;
+ if (not senkrecht) and (transformationen.tStart<>transformationen.tStop) then begin
gibAus('Binning geht nur auf eindimensionalen Daten!',3);
exit;
end;
params:=trim(params);
linien:=startetMit('(Gnuplotlinien)',params);
- x0:=kont2disk(char(ord('x')+byte(senkrecht)),exprtofloat(st,erstesArgument(params)));
- dx:=kont2diskFak(char(ord('x')+byte(senkrecht)),exprtofloat(st,erstesArgument(params)));
+ x0:=kont2disk(char(ord('x')+byte(senkrecht)),exprToFloat(sT,erstesArgument(params)));
+ dx:=kont2diskFak(char(ord('x')+byte(senkrecht)),exprToFloat(sT,erstesArgument(params)));
if pos(' ',params)>0 then begin
gibAus('Leerzeichen im Dateinamen sind nicht erlaubt!',3);
exit;
end;
- if not st then
- case Genauigkeit of
+ if not sT then
+ case genauigkeit of
gSingle:
sWerte.erzeugeBinning(senkrecht,linien,x0,dx,params);
gDouble:
@@ -4697,7 +4845,7 @@ end;
procedure tWerte.schreibeWert(var f: textfile; x,y: longint);
begin
- case Genauigkeit of
+ case genauigkeit of
gSingle: sWerte.schreibeWert(f,x,y);
gDouble: dWerte.schreibeWert(f,x,y);
gExtended: eWerte.schreibeWert(f,x,y);
@@ -4706,55 +4854,69 @@ end;
procedure tWerte.spiegle(threads: longint);
begin
- spiegle(threads,0,_tsiz-1);
+ spiegle(threads,0,_tSiz-1);
end;
-procedure tWerte.spiegle(threads,tmin,tmax: longint);
+procedure tWerte.spiegle(threads,tMin,tMax: longint);
var
i: longint;
- sts: array of tSpiegelthread;
+ sTs: array of tSpiegelThread;
fertig: boolean;
begin
- warteaufBeendigungDesLeseThreads;
- setlength(sts,threads);
- for i:=0 to length(sts)-1 do
- sts[i]:=tSpiegelthread.create(
- tmin+round(i*(tmax+1-tmin)/length(sts)),
- tmin+round((i+1)*(tmax+1-tmin)/length(sts))-1,
+ warteAufBeendigungDesLeseThreads;
+ setLength(sTs,threads);
+ for i:=0 to length(sTs)-1 do
+ sTs[i]:=tSpiegelThread.create(
+ tMin+round(i*(tMax+1-tMin)/length(sTs)),
+ tMin+round((i+1)*(tMax+1-tMin)/length(sTs))-1,
self);
repeat
sleep(10);
fertig:=true;
- for i:=0 to length(sts)-1 do
- fertig:=fertig and sts[i].fertig;
+ for i:=0 to length(sTs)-1 do
+ fertig:=fertig and sTs[i].fertig;
until fertig;
- for i:=0 to length(sts)-1 do
- sts[i].free;
- Transformationen:=tSpiegelungsTransformation.create(Transformationen);
+ for i:=0 to length(sTs)-1 do
+ sTs[i].free;
+ transformationen:=tSpiegelungsTransformation.create(transformationen);
gibAus('Alle Spiegelthreads fertig!',1);
end;
-procedure tWerte.fft2dNachbearbeitung(threads: longint; nb: tFFTDatenordnung);
+procedure tWerte.fft2dNachbearbeitung(threads: longint; nB: tFFTDatenordnung);
var
i: longint;
FNTs: array of tFFT2dNBThread;
fertig: boolean;
begin
+ if nB in [doAlleResIms,doAlleResSmi] then begin
+ _tSiz:=_tSiz*2;
+ holeRAM(3);
+ case genauigkeit of
+ gSingle:
+ sWerte.fft2dNachbearbeitungVerdoppeln(nB);
+ gDouble:
+ dWerte.fft2dNachbearbeitungVerdoppeln(nB);
+ gExtended:
+ eWerte.fft2dNachbearbeitungVerdoppeln(nB);
+ end{of case};
+ exit;
+ end;
+
// der "Rand"
case genauigkeit of
- gSingle: sWerte.fft2dNachbearbeitungA(nb);
- gDouble: dWerte.fft2dNachbearbeitungA(nb);
- gExtended: eWerte.fft2dNachbearbeitungA(nb);
+ gSingle: sWerte.fft2dNachbearbeitungA(nB);
+ gDouble: dWerte.fft2dNachbearbeitungA(nB);
+ gExtended: eWerte.fft2dNachbearbeitungA(nB);
end{of case};
// der Hauptteil (alles außer erster und mittlerer Zeile/Spalte)
- setlength(FNTs,threads);
+ setLength(FNTs,threads);
for i:=0 to length(FNTs)-1 do
FNTs[i]:=tFFT2dNBThread.create(
- round(i*(_xsteps div 2 -1)/length(FNTs))+1,
- round((i+1)*(_xsteps div 2 -1)/length(FNTs)),
+ round(i*(_xSteps div 2 -1)/length(FNTs))+1,
+ round((i+1)*(_xSteps div 2 -1)/length(FNTs)),
self,
- nb);
+ nB);
repeat
sleep(10);
fertig:=true;
@@ -4766,20 +4928,20 @@ begin
gibAus('Alle FFT2dNBThreads fertig!',1);
end;
-function tWerte.exprtofloat(st: boolean; s: string): extended;
+function tWerte.exprToFloat(sT: boolean; s: string): extended;
begin
case genauigkeit of
- gSingle: result:=matheunit.exprtofloat(st,s,swerte.params.knownValues,@callBackGetValue);
- gDouble: result:=matheunit.exprtofloat(st,s,dwerte.params.knownValues,@callBackGetValue);
- gExtended: result:=matheunit.exprtofloat(st,s,ewerte.params.knownValues,@callBackGetValue);
+ gSingle: result:=matheunit.exprToFloat(sT,s,sWerte.params.knownValues,@callBackGetValue);
+ gDouble: result:=matheunit.exprToFloat(sT,s,dWerte.params.knownValues,@callBackGetValue);
+ gExtended: result:=matheunit.exprToFloat(sT,s,eWerte.params.knownValues,@callBackGetValue);
end;
end;
-function tWerte.paramsdump: string;
+function tWerte.paramsDump: string;
begin
- result:=bezeichner+' '+inttostr(integer(genauigkeit))+' '+inttostr(_xsteps)+' '+inttostr(_tsiz)
- +' '+floattostr(sWerte.params.xstart)+'-'+floattostr(sWerte.params.xstop)
- +'x'+floattostr(sWerte.params.tstart)+'-'+floattostr(sWerte.params.tstop);
+ result:=bezeichner+' '+intToStr(integer(genauigkeit))+' '+intToStr(_xSteps)+' '+intToStr(_tSiz)
+ +' '+floatToStr(sWerte.params.xStart)+'-'+floatToStr(sWerte.params.xStop)
+ +'x'+floatToStr(sWerte.params.tStart)+'-'+floatToStr(sWerte.params.tStop);
if sWerte.params<>eWerte.params then result:='!! '+result;
end;
@@ -4843,7 +5005,7 @@ begin
if assigned(raisedException) then begin
if self is tBefehlThread then begin
if assigned((self as tBefehlThread).p) then begin
- ei:=' '''+(self as tBefehlThread).p.Executable+'''';
+ ei:=' '''+(self as tBefehlThread).p.executable+'''';
for i:=0 to (self as tBefehlThread).p.parameters.count-1 do
ei:=ei+' '''+(self as tBefehlThread).p.parameters[i]+'''';
ei:=ei;
@@ -4891,55 +5053,55 @@ var
i,j,k: longint;
out0,in0: boolean;
begin
- gibAus('LiKo-Berechnungsthread gestartet ('+inttostr(xmi)+'-'+inttostr(xma)+'x'+inttostr(tmi)+'-'+inttostr(tma)+') ...',1);
+ gibAus('LiKo-Berechnungsthread gestartet ('+intToStr(xMi)+'-'+intToStr(xMa)+'x'+intToStr(tMi)+'-'+intToStr(tMa)+') ...',1);
for i:=0 to length(liKo^)-1 do
- gibAus(liko^[i].werte.bezeichner+' * '+floattostr(liko^[i].alpha),1);
+ gibAus(liKo^[i].werte.bezeichner+' * '+floatToStr(liKo^[i].alpha),1);
out0:=true;
in0:=true;
- case liKo^[0].werte.Genauigkeit of //<<todo>>
+ case liKo^[0].werte.genauigkeit of //<<todo>>
gSingle:
for j:=tMi to tMa do begin
if (tMa-j) mod ((tMa-tMi) div 10) = 0 then
- gibAus('LiKo-Berechnungsthread: '+inttostr(j)+'/'+inttostr(tMi)+'..'+inttostr(tMa)+' ('+inttostr(xMi)+'..'+inttostr(xMa)+')',1);
+ gibAus('LiKo-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1);
for i:=xMi to xMa do begin
- pW.eWerte.werte[i+j*pW._xsteps]:=0;
+ pW.eWerte.werte[i+j*pW._xSteps]:=0;
for k:=0 to length(liKo^)-1 do begin
- pW.eWerte.werte[i+j*pW._xsteps]:=
- pW.eWerte.werte[i+j*pW._xsteps] +
- liKo^[k].alpha*liKo^[k].werte.sWerte.werte[(xOf+i) + (tOf+j)*liKo^[k].werte._xsteps];
- in0:=in0 and (liKo^[k].werte.sWerte.werte[(xOf+i) + (tOf+j)*liKo^[k].werte._xsteps]=0);
+ pW.eWerte.werte[i+j*pW._xSteps]:=
+ pW.eWerte.werte[i+j*pW._xSteps] +
+ liKo^[k].alpha*liKo^[k].werte.sWerte.werte[(xOf+i) + (tOf+j)*liKo^[k].werte._xSteps];
+ in0:=in0 and (liKo^[k].werte.sWerte.werte[(xOf+i) + (tOf+j)*liKo^[k].werte._xSteps]=0);
end;
- out0:=out0 and (pW.eWerte.werte[i+j*pW._xsteps]=0);
+ out0:=out0 and (pW.eWerte.werte[i+j*pW._xSteps]=0);
end;
end;
gDouble:
for j:=tMi to tMa do begin
if (tMa-j) mod ((tMa-tMi) div 10) = 0 then
- gibAus('LiKo-Berechnungsthread: '+inttostr(j)+'/'+inttostr(tMi)+'..'+inttostr(tMa)+' ('+inttostr(xMi)+'..'+inttostr(xMa)+')',1);
+ gibAus('LiKo-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1);
for i:=xMi to xMa do begin
- pW.eWerte.werte[i+j*pW._xsteps]:=0;
+ pW.eWerte.werte[i+j*pW._xSteps]:=0;
for k:=0 to length(liKo^)-1 do begin
- pW.eWerte.werte[i+j*pW._xsteps]:=
- pW.eWerte.werte[i+j*pW._xsteps] +
- liKo^[k].alpha*liKo^[k].werte.dWerte.werte[(xOf+i) + (tOf+j)*liKo^[k].werte._xsteps];
- in0:=in0 and (liKo^[k].werte.dWerte.werte[(xOf+i) + (tOf+j)*liKo^[k].werte._xsteps]=0);
+ pW.eWerte.werte[i+j*pW._xSteps]:=
+ pW.eWerte.werte[i+j*pW._xSteps] +
+ liKo^[k].alpha*liKo^[k].werte.dWerte.werte[(xOf+i) + (tOf+j)*liKo^[k].werte._xSteps];
+ in0:=in0 and (liKo^[k].werte.dWerte.werte[(xOf+i) + (tOf+j)*liKo^[k].werte._xSteps]=0);
end;
- out0:=out0 and (pW.eWerte.werte[i+j*pW._xsteps]=0);
+ out0:=out0 and (pW.eWerte.werte[i+j*pW._xSteps]=0);
end;
end;
gExtended:
for j:=tMi to tMa do begin
if (tMa-j) mod ((tMa-tMi) div 10) = 0 then
- gibAus('LiKo-Berechnungsthread: '+inttostr(j)+'/'+inttostr(tMi)+'..'+inttostr(tMa)+' ('+inttostr(xMi)+'..'+inttostr(xMa)+')',1);
+ gibAus('LiKo-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1);
for i:=xMi to xMa do begin
- pW.eWerte.werte[i+j*pW._xsteps]:=0;
+ pW.eWerte.werte[i+j*pW._xSteps]:=0;
for k:=0 to length(liKo^)-1 do begin
- pW.eWerte.werte[i+j*pW._xsteps]:=
- pW.eWerte.werte[i+j*pW._xsteps] +
- liKo^[k].alpha*liKo^[k].werte.eWerte.werte[(xOf+i) + (tOf+j)*liKo^[k].werte._xsteps];
- in0:=in0 and (liKo^[k].werte.eWerte.werte[(xOf+i) + (tOf+j)*liKo^[k].werte._xsteps]=0);
+ pW.eWerte.werte[i+j*pW._xSteps]:=
+ pW.eWerte.werte[i+j*pW._xSteps] +
+ liKo^[k].alpha*liKo^[k].werte.eWerte.werte[(xOf+i) + (tOf+j)*liKo^[k].werte._xSteps];
+ in0:=in0 and (liKo^[k].werte.eWerte.werte[(xOf+i) + (tOf+j)*liKo^[k].werte._xSteps]=0);
end;
- out0:=out0 and (pW.eWerte.werte[i+j*pW._xsteps]=0);
+ out0:=out0 and (pW.eWerte.werte[i+j*pW._xSteps]=0);
end;
end;
end{of Case};
@@ -4976,172 +5138,172 @@ begin
i01:=true;
i02:=true;
o0:=true;
- case dend.Genauigkeit of
+ case dend.genauigkeit of
gSingle:
- case sor.Genauigkeit of
+ case sor.genauigkeit of
gSingle: // single / single
for j:=tMi to tMa do begin
if (tMa-j) mod ((tMa-tMi) div 10) = 0 then
- gibAus('Quotient-Berechnungsthread: '+inttostr(j)+'/'+inttostr(tMi)+'..'+inttostr(tMa)+' ('+inttostr(xMi)+'..'+inttostr(xMa)+')',1);
+ gibAus('Quotient-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1);
for i:=xMi to xMa do
- if abs(sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps])<eps then
- quot.eWerte.werte[i+j*quot._xsteps]:=
- dend.sWerte.werte[(xOf+i) + (tOf+j)*dend._xsteps] /
- eps*sign(sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps])
+ if abs(sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps])<eps then
+ quot.eWerte.werte[i+j*quot._xSteps]:=
+ dend.sWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] /
+ eps*sign(sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps])
else
- quot.eWerte.werte[i+j*quot._xsteps]:=
- dend.sWerte.werte[(xOf+i) + (tOf+j)*dend._xsteps] /
- sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps];
- i01:=i01 and (dend.sWerte.werte[(xOf+i) + (tOf+j)*dend._xsteps]=0);
- i02:=i02 and (sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps]=0);
- o0:=o0 and (quot.eWerte.werte[i+j*quot._xsteps]=0);
+ quot.eWerte.werte[i+j*quot._xSteps]:=
+ dend.sWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] /
+ sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps];
+ i01:=i01 and (dend.sWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps]=0);
+ i02:=i02 and (sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]=0);
+ o0:=o0 and (quot.eWerte.werte[i+j*quot._xSteps]=0);
end;
gDouble: // single / double
for j:=tMi to tMa do begin
if (tMa-j) mod ((tMa-tMi) div 10) = 0 then
- gibAus('Quotient-Berechnungsthread: '+inttostr(j)+'/'+inttostr(tMi)+'..'+inttostr(tMa)+' ('+inttostr(xMi)+'..'+inttostr(xMa)+')',1);
+ gibAus('Quotient-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1);
for i:=xMi to xMa do begin
- if abs(sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps])<eps then
- quot.eWerte.werte[i+j*quot._xsteps]:=
- dend.sWerte.werte[(xOf+i) + (tOf+j)*dend._xsteps] /
- eps*sign(sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps])
+ if abs(sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps])<eps then
+ quot.eWerte.werte[i+j*quot._xSteps]:=
+ dend.sWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] /
+ eps*sign(sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps])
else
- quot.eWerte.werte[i+j*quot._xsteps]:=
- dend.sWerte.werte[(xOf+i) + (tOf+j)*dend._xsteps] /
- sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps];
- i01:=i01 and (dend.sWerte.werte[(xOf+i) + (tOf+j)*dend._xsteps]=0);
- i02:=i02 and (sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps]=0);
- o0:=o0 and (quot.eWerte.werte[i+j*quot._xsteps]=0);
+ quot.eWerte.werte[i+j*quot._xSteps]:=
+ dend.sWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] /
+ sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps];
+ i01:=i01 and (dend.sWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps]=0);
+ i02:=i02 and (sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]=0);
+ o0:=o0 and (quot.eWerte.werte[i+j*quot._xSteps]=0);
end;
end;
gExtended: // single / extended
for j:=tMi to tMa do begin
if (tMa-j) mod ((tMa-tMi) div 10) = 0 then
- gibAus('Quotient-Berechnungsthread: '+inttostr(j)+'/'+inttostr(tMi)+'..'+inttostr(tMa)+' ('+inttostr(xMi)+'..'+inttostr(xMa)+')',1);
+ gibAus('Quotient-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1);
for i:=xMi to xMa do begin
- if abs(sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps])<eps then
- quot.eWerte.werte[i+j*quot._xsteps]:=
- dend.sWerte.werte[(xOf+i) + (tOf+j)*dend._xsteps] /
- eps*sign(sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps])
+ if abs(sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps])<eps then
+ quot.eWerte.werte[i+j*quot._xSteps]:=
+ dend.sWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] /
+ eps*sign(sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps])
else
- quot.eWerte.werte[i+j*quot._xsteps]:=
- dend.sWerte.werte[(xOf+i) + (tOf+j)*dend._xsteps] /
- sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps];
- i01:=i01 and (dend.sWerte.werte[(xOf+i) + (tOf+j)*dend._xsteps]=0);
- i02:=i02 and (sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps]=0);
- o0:=o0 and (quot.eWerte.werte[i+j*quot._xsteps]=0);
+ quot.eWerte.werte[i+j*quot._xSteps]:=
+ dend.sWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] /
+ sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps];
+ i01:=i01 and (dend.sWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps]=0);
+ i02:=i02 and (sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]=0);
+ o0:=o0 and (quot.eWerte.werte[i+j*quot._xSteps]=0);
end;
end;
end{of case};
gDouble:
- case sor.Genauigkeit of
+ case sor.genauigkeit of
gSingle: // double / single
for j:=tMi to tMa do begin
if (tMa-j) mod ((tMa-tMi) div 10) = 0 then
- gibAus('Quotient-Berechnungsthread: '+inttostr(j)+'/'+inttostr(tMi)+'..'+inttostr(tMa)+' ('+inttostr(xMi)+'..'+inttostr(xMa)+')',1);
+ gibAus('Quotient-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1);
for i:=xMi to xMa do
- if abs(sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps])<eps then
- quot.eWerte.werte[i+j*quot._xsteps]:=
- dend.dWerte.werte[(xOf+i) + (tOf+j)*dend._xsteps] /
- eps*sign(sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps])
+ if abs(sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps])<eps then
+ quot.eWerte.werte[i+j*quot._xSteps]:=
+ dend.dWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] /
+ eps*sign(sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps])
else
- quot.eWerte.werte[i+j*quot._xsteps]:=
- dend.dWerte.werte[(xOf+i) + (tOf+j)*dend._xsteps] /
- sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps];
- i01:=i01 and (dend.dWerte.werte[(xOf+i) + (tOf+j)*dend._xsteps]=0);
- i02:=i02 and (sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps]=0);
- o0:=o0 and (quot.eWerte.werte[i+j*quot._xsteps]=0);
+ quot.eWerte.werte[i+j*quot._xSteps]:=
+ dend.dWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] /
+ sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps];
+ i01:=i01 and (dend.dWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps]=0);
+ i02:=i02 and (sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]=0);
+ o0:=o0 and (quot.eWerte.werte[i+j*quot._xSteps]=0);
end;
gDouble: // double / double
for j:=tMi to tMa do begin
if (tMa-j) mod ((tMa-tMi) div 10) = 0 then
- gibAus('Quotient-Berechnungsthread: '+inttostr(j)+'/'+inttostr(tMi)+'..'+inttostr(tMa)+' ('+inttostr(xMi)+'..'+inttostr(xMa)+')',1);
+ gibAus('Quotient-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1);
for i:=xMi to xMa do begin
- if abs(sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps])<eps then
- quot.eWerte.werte[i+j*quot._xsteps]:=
- dend.dWerte.werte[(xOf+i) + (tOf+j)*dend._xsteps] /
- eps*sign(sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps])
+ if abs(sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps])<eps then
+ quot.eWerte.werte[i+j*quot._xSteps]:=
+ dend.dWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] /
+ eps*sign(sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps])
else
- quot.eWerte.werte[i+j*quot._xsteps]:=
- dend.dWerte.werte[(xOf+i) + (tOf+j)*dend._xsteps] /
- sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps];
- i01:=i01 and (dend.dWerte.werte[(xOf+i) + (tOf+j)*dend._xsteps]=0);
- i02:=i02 and (sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps]=0);
- o0:=o0 and (quot.eWerte.werte[i+j*quot._xsteps]=0);
+ quot.eWerte.werte[i+j*quot._xSteps]:=
+ dend.dWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] /
+ sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps];
+ i01:=i01 and (dend.dWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps]=0);
+ i02:=i02 and (sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]=0);
+ o0:=o0 and (quot.eWerte.werte[i+j*quot._xSteps]=0);
end;
end;
gExtended: // double / extended
for j:=tMi to tMa do begin
if (tMa-j) mod ((tMa-tMi) div 10) = 0 then
- gibAus('Quotient-Berechnungsthread: '+inttostr(j)+'/'+inttostr(tMi)+'..'+inttostr(tMa)+' ('+inttostr(xMi)+'..'+inttostr(xMa)+')',1);
+ gibAus('Quotient-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1);
for i:=xMi to xMa do begin
- if abs(sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps])<eps then
- quot.eWerte.werte[i+j*quot._xsteps]:=
- dend.dWerte.werte[(xOf+i) + (tOf+j)*dend._xsteps] /
- eps*sign(sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps])
+ if abs(sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps])<eps then
+ quot.eWerte.werte[i+j*quot._xSteps]:=
+ dend.dWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] /
+ eps*sign(sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps])
else
- quot.eWerte.werte[i+j*quot._xsteps]:=
- dend.dWerte.werte[(xOf+i) + (tOf+j)*dend._xsteps] /
- sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps];
- i01:=i01 and (dend.dWerte.werte[(xOf+i) + (tOf+j)*dend._xsteps]=0);
- i02:=i02 and (sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps]=0);
- o0:=o0 and (quot.eWerte.werte[i+j*quot._xsteps]=0);
+ quot.eWerte.werte[i+j*quot._xSteps]:=
+ dend.dWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] /
+ sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps];
+ i01:=i01 and (dend.dWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps]=0);
+ i02:=i02 and (sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]=0);
+ o0:=o0 and (quot.eWerte.werte[i+j*quot._xSteps]=0);
end;
end;
end{of case};
gExtended:
- case sor.Genauigkeit of
+ case sor.genauigkeit of
gSingle: // extended / single
for j:=tMi to tMa do begin
if (tMa-j) mod ((tMa-tMi) div 10) = 0 then
- gibAus('Quotient-Berechnungsthread: '+inttostr(j)+'/'+inttostr(tMi)+'..'+inttostr(tMa)+' ('+inttostr(xMi)+'..'+inttostr(xMa)+')',1);
+ gibAus('Quotient-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1);
for i:=xMi to xMa do
- if abs(sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps])<eps then
- quot.eWerte.werte[i+j*quot._xsteps]:=
- dend.eWerte.werte[(xOf+i) + (tOf+j)*dend._xsteps] /
- eps*sign(sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps])
+ if abs(sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps])<eps then
+ quot.eWerte.werte[i+j*quot._xSteps]:=
+ dend.eWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] /
+ eps*sign(sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps])
else
- quot.eWerte.werte[i+j*quot._xsteps]:=
- dend.eWerte.werte[(xOf+i) + (tOf+j)*dend._xsteps] /
- sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps];
- i01:=i01 and (dend.eWerte.werte[(xOf+i) + (tOf+j)*dend._xsteps]=0);
- i02:=i02 and (sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps]=0);
- o0:=o0 and (quot.eWerte.werte[i+j*quot._xsteps]=0);
+ quot.eWerte.werte[i+j*quot._xSteps]:=
+ dend.eWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] /
+ sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps];
+ i01:=i01 and (dend.eWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps]=0);
+ i02:=i02 and (sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]=0);
+ o0:=o0 and (quot.eWerte.werte[i+j*quot._xSteps]=0);
end;
gDouble: // extended / double
for j:=tMi to tMa do begin
if (tMa-j) mod ((tMa-tMi) div 10) = 0 then
- gibAus('Quotient-Berechnungsthread: '+inttostr(j)+'/'+inttostr(tMi)+'..'+inttostr(tMa)+' ('+inttostr(xMi)+'..'+inttostr(xMa)+')',1);
+ gibAus('Quotient-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1);
for i:=xMi to xMa do begin
- if abs(sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps])<eps then
- quot.eWerte.werte[i+j*quot._xsteps]:=
- dend.eWerte.werte[(xOf+i) + (tOf+j)*dend._xsteps] /
- eps*sign(sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps])
+ if abs(sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps])<eps then
+ quot.eWerte.werte[i+j*quot._xSteps]:=
+ dend.eWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] /
+ eps*sign(sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps])
else
- quot.eWerte.werte[i+j*quot._xsteps]:=
- dend.eWerte.werte[(xOf+i) + (tOf+j)*dend._xsteps] /
- sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps];
- i01:=i01 and (dend.eWerte.werte[(xOf+i) + (tOf+j)*dend._xsteps]=0);
- i02:=i02 and (sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps]=0);
- o0:=o0 and (quot.eWerte.werte[i+j*quot._xsteps]=0);
+ quot.eWerte.werte[i+j*quot._xSteps]:=
+ dend.eWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] /
+ sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps];
+ i01:=i01 and (dend.eWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps]=0);
+ i02:=i02 and (sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]=0);
+ o0:=o0 and (quot.eWerte.werte[i+j*quot._xSteps]=0);
end;
end;
gExtended: // extended / extended
for j:=tMi to tMa do begin
if (tMa-j) mod ((tMa-tMi) div 10) = 0 then
- gibAus('Quotient-Berechnungsthread: '+inttostr(j)+'/'+inttostr(tMi)+'..'+inttostr(tMa)+' ('+inttostr(xMi)+'..'+inttostr(xMa)+')',1);
+ gibAus('Quotient-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1);
for i:=xMi to xMa do begin
- if abs(sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps])<eps then
- quot.eWerte.werte[i+j*quot._xsteps]:=
- dend.eWerte.werte[(xOf+i) + (tOf+j)*dend._xsteps] /
- eps*sign(sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps])
+ if abs(sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps])<eps then
+ quot.eWerte.werte[i+j*quot._xSteps]:=
+ dend.eWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] /
+ eps*sign(sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps])
else
- quot.eWerte.werte[i+j*quot._xsteps]:=
- dend.eWerte.werte[(xOf+i) + (tOf+j)*dend._xsteps] /
- sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps];
- i01:=i01 and (dend.eWerte.werte[(xOf+i) + (tOf+j)*dend._xsteps]=0);
- i02:=i02 and (sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xsteps]=0);
- o0:=o0 and (quot.eWerte.werte[i+j*quot._xsteps]=0);
+ quot.eWerte.werte[i+j*quot._xSteps]:=
+ dend.eWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] /
+ sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps];
+ i01:=i01 and (dend.eWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps]=0);
+ i02:=i02 and (sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]=0);
+ o0:=o0 and (quot.eWerte.werte[i+j*quot._xSteps]=0);
end;
end;
end{of case};
@@ -5180,122 +5342,122 @@ begin
i02:=true;
o0:=true;
- case f1.Genauigkeit of
+ case f1.genauigkeit of
gSingle:
- case f2.Genauigkeit of
+ case f2.genauigkeit of
gSingle: // single * single
for j:=tMi to tMa do begin
if (tMa-j) mod ((tMa-tMi) div 10) = 0 then
- gibAus('Produkt-Berechnungsthread: '+inttostr(j)+'/'+inttostr(tMi)+'..'+inttostr(tMa)+' ('+inttostr(xMi)+'..'+inttostr(xMa)+')',1);
+ gibAus('Produkt-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1);
for i:=xMi to xMa do
- pro.eWerte.werte[i+j*pro._xsteps]:=
- f1.sWerte.werte[(xOf+i) + (tOf+j)*f1._xsteps] *
- f2.sWerte.werte[(xOf+i) + (tOf+j)*f2._xsteps];
- i01:=i01 and (f1.sWerte.werte[(xOf+i) + (tOf+j)*f1._xsteps]=0);
- i02:=i02 and (f2.sWerte.werte[(xOf+i) + (tOf+j)*f2._xsteps]=0);
- o0:=o0 and (pro.eWerte.werte[i+j*pro._xsteps]=0);
+ pro.eWerte.werte[i+j*pro._xSteps]:=
+ f1.sWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps] *
+ f2.sWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps];
+ i01:=i01 and (f1.sWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps]=0);
+ i02:=i02 and (f2.sWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps]=0);
+ o0:=o0 and (pro.eWerte.werte[i+j*pro._xSteps]=0);
end;
gDouble: // single * double
for j:=tMi to tMa do begin
if (tMa-j) mod ((tMa-tMi) div 10) = 0 then
- gibAus('Produkt-Berechnungsthread: '+inttostr(j)+'/'+inttostr(tMi)+'..'+inttostr(tMa)+' ('+inttostr(xMi)+'..'+inttostr(xMa)+')',1);
+ gibAus('Produkt-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1);
for i:=xMi to xMa do
- pro.eWerte.werte[i+j*pro._xsteps]:=
- f1.sWerte.werte[(xOf+i) + (tOf+j)*f1._xsteps] *
- f2.dWerte.werte[(xOf+i) + (tOf+j)*f2._xsteps];
- i01:=i01 and (f1.sWerte.werte[(xOf+i) + (tOf+j)*f1._xsteps]=0);
- i02:=i02 and (f2.dWerte.werte[(xOf+i) + (tOf+j)*f2._xsteps]=0);
- o0:=o0 and (pro.eWerte.werte[i+j*pro._xsteps]=0);
+ pro.eWerte.werte[i+j*pro._xSteps]:=
+ f1.sWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps] *
+ f2.dWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps];
+ i01:=i01 and (f1.sWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps]=0);
+ i02:=i02 and (f2.dWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps]=0);
+ o0:=o0 and (pro.eWerte.werte[i+j*pro._xSteps]=0);
end;
gExtended: // single * extended
for j:=tMi to tMa do begin
if (tMa-j) mod ((tMa-tMi) div 10) = 0 then
- gibAus('Produkt-Berechnungsthread: '+inttostr(j)+'/'+inttostr(tMi)+'..'+inttostr(tMa)+' ('+inttostr(xMi)+'..'+inttostr(xMa)+')',1);
+ gibAus('Produkt-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1);
for i:=xMi to xMa do
- pro.eWerte.werte[i+j*pro._xsteps]:=
- f1.sWerte.werte[(xOf+i) + (tOf+j)*f1._xsteps] *
- f2.eWerte.werte[(xOf+i) + (tOf+j)*f2._xsteps];
- i01:=i01 and (f1.sWerte.werte[(xOf+i) + (tOf+j)*f1._xsteps]=0);
- i02:=i02 and (f2.eWerte.werte[(xOf+i) + (tOf+j)*f2._xsteps]=0);
- o0:=o0 and (pro.eWerte.werte[i+j*pro._xsteps]=0);
+ pro.eWerte.werte[i+j*pro._xSteps]:=
+ f1.sWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps] *
+ f2.eWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps];
+ i01:=i01 and (f1.sWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps]=0);
+ i02:=i02 and (f2.eWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps]=0);
+ o0:=o0 and (pro.eWerte.werte[i+j*pro._xSteps]=0);
end;
end{of case};
gDouble:
- case f2.Genauigkeit of
+ case f2.genauigkeit of
gSingle: // double * single
for j:=tMi to tMa do begin
if (tMa-j) mod ((tMa-tMi) div 10) = 0 then
- gibAus('Produkt-Berechnungsthread: '+inttostr(j)+'/'+inttostr(tMi)+'..'+inttostr(tMa)+' ('+inttostr(xMi)+'..'+inttostr(xMa)+')',1);
+ gibAus('Produkt-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1);
for i:=xMi to xMa do
- pro.eWerte.werte[i+j*pro._xsteps]:=
- f1.dWerte.werte[(xOf+i) + (tOf+j)*f1._xsteps] *
- f2.sWerte.werte[(xOf+i) + (tOf+j)*f2._xsteps];
- i01:=i01 and (f1.dWerte.werte[(xOf+i) + (tOf+j)*f1._xsteps]=0);
- i02:=i02 and (f2.sWerte.werte[(xOf+i) + (tOf+j)*f2._xsteps]=0);
- o0:=o0 and (pro.eWerte.werte[i+j*pro._xsteps]=0);
+ pro.eWerte.werte[i+j*pro._xSteps]:=
+ f1.dWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps] *
+ f2.sWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps];
+ i01:=i01 and (f1.dWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps]=0);
+ i02:=i02 and (f2.sWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps]=0);
+ o0:=o0 and (pro.eWerte.werte[i+j*pro._xSteps]=0);
end;
gDouble: // double * double
for j:=tMi to tMa do begin
if (tMa-j) mod ((tMa-tMi) div 10) = 0 then
- gibAus('Produkt-Berechnungsthread: '+inttostr(j)+'/'+inttostr(tMi)+'..'+inttostr(tMa)+' ('+inttostr(xMi)+'..'+inttostr(xMa)+')',1);
+ gibAus('Produkt-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1);
for i:=xMi to xMa do
- pro.eWerte.werte[i+j*pro._xsteps]:=
- f1.dWerte.werte[(xOf+i) + (tOf+j)*f1._xsteps] *
- f2.dWerte.werte[(xOf+i) + (tOf+j)*f2._xsteps];
- i01:=i01 and (f1.dWerte.werte[(xOf+i) + (tOf+j)*f1._xsteps]=0);
- i02:=i02 and (f2.dWerte.werte[(xOf+i) + (tOf+j)*f2._xsteps]=0);
- o0:=o0 and (pro.eWerte.werte[i+j*pro._xsteps]=0);
+ pro.eWerte.werte[i+j*pro._xSteps]:=
+ f1.dWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps] *
+ f2.dWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps];
+ i01:=i01 and (f1.dWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps]=0);
+ i02:=i02 and (f2.dWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps]=0);
+ o0:=o0 and (pro.eWerte.werte[i+j*pro._xSteps]=0);
end;
gExtended: // double * extended
for j:=tMi to tMa do begin
if (tMa-j) mod ((tMa-tMi) div 10) = 0 then
- gibAus('Produkt-Berechnungsthread: '+inttostr(j)+'/'+inttostr(tMi)+'..'+inttostr(tMa)+' ('+inttostr(xMi)+'..'+inttostr(xMa)+')',1);
+ gibAus('Produkt-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1);
for i:=xMi to xMa do
- pro.eWerte.werte[i+j*pro._xsteps]:=
- f1.dWerte.werte[(xOf+i) + (tOf+j)*f1._xsteps] *
- f2.eWerte.werte[(xOf+i) + (tOf+j)*f2._xsteps];
- i01:=i01 and (f1.dWerte.werte[(xOf+i) + (tOf+j)*f1._xsteps]=0);
- i02:=i02 and (f2.eWerte.werte[(xOf+i) + (tOf+j)*f2._xsteps]=0);
- o0:=o0 and (pro.eWerte.werte[i+j*pro._xsteps]=0);
+ pro.eWerte.werte[i+j*pro._xSteps]:=
+ f1.dWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps] *
+ f2.eWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps];
+ i01:=i01 and (f1.dWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps]=0);
+ i02:=i02 and (f2.eWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps]=0);
+ o0:=o0 and (pro.eWerte.werte[i+j*pro._xSteps]=0);
end;
end{of case};
gExtended:
- case f2.Genauigkeit of
+ case f2.genauigkeit of
gSingle: // extended * single
for j:=tMi to tMa do begin
if (tMa-j) mod ((tMa-tMi) div 10) = 0 then
- gibAus('Produkt-Berechnungsthread: '+inttostr(j)+'/'+inttostr(tMi)+'..'+inttostr(tMa)+' ('+inttostr(xMi)+'..'+inttostr(xMa)+')',1);
+ gibAus('Produkt-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1);
for i:=xMi to xMa do
- pro.eWerte.werte[i+j*pro._xsteps]:=
- f1.eWerte.werte[(xOf+i) + (tOf+j)*f1._xsteps] *
- f2.sWerte.werte[(xOf+i) + (tOf+j)*f2._xsteps];
- i01:=i01 and (f1.eWerte.werte[(xOf+i) + (tOf+j)*f1._xsteps]=0);
- i02:=i02 and (f2.sWerte.werte[(xOf+i) + (tOf+j)*f2._xsteps]=0);
- o0:=o0 and (pro.eWerte.werte[i+j*pro._xsteps]=0);
+ pro.eWerte.werte[i+j*pro._xSteps]:=
+ f1.eWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps] *
+ f2.sWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps];
+ i01:=i01 and (f1.eWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps]=0);
+ i02:=i02 and (f2.sWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps]=0);
+ o0:=o0 and (pro.eWerte.werte[i+j*pro._xSteps]=0);
end;
gDouble: // extended * double
for j:=tMi to tMa do begin
if (tMa-j) mod ((tMa-tMi) div 10) = 0 then
- gibAus('Produkt-Berechnungsthread: '+inttostr(j)+'/'+inttostr(tMi)+'..'+inttostr(tMa)+' ('+inttostr(xMi)+'..'+inttostr(xMa)+')',1);
+ gibAus('Produkt-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1);
for i:=xMi to xMa do
- pro.eWerte.werte[i+j*pro._xsteps]:=
- f1.eWerte.werte[(xOf+i) + (tOf+j)*f1._xsteps] *
- f2.dWerte.werte[(xOf+i) + (tOf+j)*f2._xsteps];
- i01:=i01 and (f1.eWerte.werte[(xOf+i) + (tOf+j)*f1._xsteps]=0);
- i02:=i02 and (f2.dWerte.werte[(xOf+i) + (tOf+j)*f2._xsteps]=0);
- o0:=o0 and (pro.eWerte.werte[i+j*pro._xsteps]=0);
+ pro.eWerte.werte[i+j*pro._xSteps]:=
+ f1.eWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps] *
+ f2.dWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps];
+ i01:=i01 and (f1.eWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps]=0);
+ i02:=i02 and (f2.dWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps]=0);
+ o0:=o0 and (pro.eWerte.werte[i+j*pro._xSteps]=0);
end;
gExtended: // extended * extended
for j:=tMi to tMa do begin
if (tMa-j) mod ((tMa-tMi) div 10) = 0 then
- gibAus('Produkt-Berechnungsthread: '+inttostr(j)+'/'+inttostr(tMi)+'..'+inttostr(tMa)+' ('+inttostr(xMi)+'..'+inttostr(xMa)+')',1);
+ gibAus('Produkt-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1);
for i:=xMi to xMa do
- pro.eWerte.werte[i+j*pro._xsteps]:=
- f1.eWerte.werte[(xOf+i) + (tOf+j)*f1._xsteps] *
- f2.eWerte.werte[(xOf+i) + (tOf+j)*f2._xsteps];
- i01:=i01 and (f1.eWerte.werte[(xOf+i) + (tOf+j)*f1._xsteps]=0);
- i02:=i02 and (f2.eWerte.werte[(xOf+i) + (tOf+j)*f2._xsteps]=0);
- o0:=o0 and (pro.eWerte.werte[i+j*pro._xsteps]=0);
+ pro.eWerte.werte[i+j*pro._xSteps]:=
+ f1.eWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps] *
+ f2.eWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps];
+ i01:=i01 and (f1.eWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps]=0);
+ i02:=i02 and (f2.eWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps]=0);
+ o0:=o0 and (pro.eWerte.werte[i+j*pro._xSteps]=0);
end;
end{of case};
end{of Case};
@@ -5306,103 +5468,103 @@ begin
gibAus('... und fertig!',1);
end;
-// tBilderthread ***************************************************************
+// tBilderThread ***************************************************************
-constructor tBilderthread.create(i,maxthreads,ibreite,ihoehe,lo,oo,ro,uo: longint; const wes: tWerteArray; xmin,xmax,tmin,tmax: Longint; xzoom,yzoom: extended; Nachbearbeitungen: tTransformationArray; paletten: pTPalettenArray; beschri: pTBeschriftungen; rm: boolean);
+constructor tBilderThread.create(i,maxThreads,iBreite,iHoehe,lO,oO,rO,uO: longint; const wes: tWerteArray; xMin,xMax,tMin,tMax: longint; xZoom,yZoom: extended; nachbearbeitungen: tTransformationArray; paletten: pTPalettenArray; beschri: pTBeschriftungen; rm: boolean);
var
ii: longint;
begin
inherited create;
beschr:=beschri;
nummer:=i;
- mt:=maxthreads;
- whoehe:=ihoehe;
- gesbreite:=ibreite;
- lof:=lo;
- oof:=oo;
- rof:=ro;
- uof:=uo;
+ mT:=maxThreads;
+ wHoehe:=iHoehe;
+ gesBreite:=iBreite;
+ lOf:=lO;
+ oOf:=oO;
+ rOf:=rO;
+ uOf:=uO;
ws:=wes;
- xmi:=xmin;
- xma:=xmax;
- tmi:=tmin;
- tma:=tmax;
- xz:=xzoom;
- yz:=yzoom;
- nbs:=Nachbearbeitungen;
- setlength(pals,length(paletten));
+ xMi:=xMin;
+ xMa:=xMax;
+ tMi:=tMin;
+ tMa:=tMax;
+ xZ:=xZoom;
+ yZ:=yZoom;
+ nbs:=nachbearbeitungen;
+ setLength(pals,length(paletten));
for ii:=0 to length(pals)-1 do
pals[ii]:=paletten[ii]^.farben;
rahmen:=rm;
- xpmi:=nummer*((gesbreite+lof+rof) div mt)-lof;
- if nummer=mt-1 then xpma:=gesbreite+rof-1 // der letzte Thread bekommt den Rest
- else xpma:=(nummer+1)*((gesbreite+lof+rof) div mt)-lof-1;
- breite:=xpma-xpmi+1;
- wbreite:=max(0,min(gesbreite,xpma+1)-max(0,xpmi));
-// wbreite:=max(gesbreite div mt,byte(nummer=mt-1)*(gesbreite-(gesbreite div mt)*(mt-1)));
-// breite:=wbreite+lof*byte(nummer=0)+rof*byte(nummer=mt-1);
- hoehe:=oof+whoehe+uof;
- gibAus('Werte: '+inttostr(xmi)+'-'+inttostr(xma)+'x'+inttostr(tmi)+'-'+inttostr(tma)+' ('+inttostr(wbreite)+'), Pixel: '+inttostr(xpmi)+'-'+inttostr(xpma)+' ('+inttostr(breite)+')',1);
- gibAus('Thread '+inttostr(nummer)+': hole '
- +inttostr(round(((sizeof(extended)+sizeof(longint))*length(wes)*whoehe*wbreite+
- sizeof(tRGB)*hoehe*breite)/1024/1024))+'MB RAM ...',1);
- setlength(wertes,length(wes));
- setlength(anzahlens,length(wes));
+ xPMi:=nummer*((gesBreite+lOf+rOf) div mT)-lOf;
+ if nummer=mT-1 then xPMa:=gesBreite+rOf-1 // der letzte Thread bekommt den Rest
+ else xPMa:=(nummer+1)*((gesBreite+lOf+rOf) div mT)-lOf-1;
+ breite:=xPMa-xPMi+1;
+ wBreite:=max(0,min(gesBreite,xPMa+1)-max(0,xPMi));
+// wBreite:=max(gesBreite div mT,byte(nummer=mT-1)*(gesBreite-(gesBreite div mT)*(mT-1)));
+// breite:=wBreite+lOf*byte(nummer=0)+rOf*byte(nummer=mT-1);
+ hoehe:=oOf+wHoehe+uOf;
+ gibAus('Werte: '+intToStr(xMi)+'-'+intToStr(xMa)+'x'+intToStr(tMi)+'-'+intToStr(tMa)+' ('+intToStr(wBreite)+'), Pixel: '+intToStr(xPMi)+'-'+intToStr(xPMa)+' ('+intToStr(breite)+')',1);
+ gibAus('Thread '+intToStr(nummer)+': hole '
+ +intToStr(round(((sizeOf(extended)+sizeOf(longint))*length(wes)*wHoehe*wBreite+
+ sizeOf(tRGB)*hoehe*breite)/1024/1024))+'MB RAM ...',1);
+ setLength(wertes,length(wes));
+ setLength(anzahlens,length(wes));
for ii:=0 to length(wertes)-1 do begin
- setlength(wertes[ii],whoehe*wbreite);
- setlength(anzahlens[ii],length(wertes[ii]));
+ setLength(wertes[ii],wHoehe*wBreite);
+ setLength(anzahlens[ii],length(wertes[ii]));
end;
- setlength(farben,hoehe*breite);
- gibAus('Thread '+inttostr(nummer)+' hat jetzt seinen Speicher.',1);
+ setLength(farben,hoehe*breite);
+ gibAus('Thread '+intToStr(nummer)+' hat jetzt seinen Speicher.',1);
end;
-destructor tBilderthread.destroy;
+destructor tBilderThread.destroy;
var
ii: longint;
begin
- setlength(farben,0);
+ setLength(farben,0);
for ii:=0 to length(wertes)-1 do
- setlength(wertes[ii],0);
- setlength(wertes,0);
+ setLength(wertes[ii],0);
+ setLength(wertes,0);
for ii:=0 to length(anzahlens)-1 do
- setlength(anzahlens[ii],0);
- setlength(anzahlens,0);
+ setLength(anzahlens[ii],0);
+ setLength(anzahlens,0);
inherited destroy;
end;
-procedure tBilderthread.stExecute;
+procedure tBilderThread.stExecute;
var
i,j,k: longint;
wert: extended;
b: boolean;
frb: tRGB;
begin
- gibAus('Thread '+inttostr(nummer)+' gestartet!',1);
+ gibAus('Thread '+intToStr(nummer)+' gestartet!',1);
for i:=0 to length(ws)-1 do
- case ws[i].Genauigkeit of
- gSingle: if not ws[i].sWerte.zuPixelWerten(whoehe,wbreite,xpmi,xmi,tmi,xz,yz,@wertes[i],@anzahlens[i]) then exit;
- gDouble: if not ws[i].dWerte.zuPixelWerten(whoehe,wbreite,xpmi,xmi,tmi,xz,yz,@wertes[i],@anzahlens[i]) then exit;
- gExtended: if not ws[i].eWerte.zuPixelWerten(whoehe,wbreite,xpmi,xmi,tmi,xz,yz,@wertes[i],@anzahlens[i]) then exit;
+ case ws[i].genauigkeit of
+ gSingle: if not ws[i].sWerte.zuPixelWerten(wHoehe,wBreite,xPMi,xMi,tMi,xZ,yZ,@wertes[i],@anzahlens[i]) then exit;
+ gDouble: if not ws[i].dWerte.zuPixelWerten(wHoehe,wBreite,xPMi,xMi,tMi,xZ,yZ,@wertes[i],@anzahlens[i]) then exit;
+ gExtended: if not ws[i].eWerte.zuPixelWerten(wHoehe,wBreite,xPMi,xMi,tMi,xZ,yZ,@wertes[i],@anzahlens[i]) then exit;
end{of case};
for i:=0 to length(wertes)-1 do
for j:=0 to length(wertes[i])-1 do
if anzahlens[i,j]=0 then begin
- gibAus('Thread '+inttostr(nummer)+': keine Werte in ['+inttostr(i)+'] '+inttostr(j mod wBreite)+':'+inttostr(j div wBreite)+'!',1);
+ gibAus('Thread '+intToStr(nummer)+': keine Werte in ['+intToStr(i)+'] '+intToStr(j mod wBreite)+':'+intToStr(j div wBreite)+'!',1);
exit;
end;
- gibAus('Thread '+inttostr(nummer)+': Werte -> Bild ...',1);
- for j:=-oof to whoehe-1+uof do
- for i:=xpmi to xpma do
- if (j>=0) and (j<whoehe) and (i>=0) and (i<gesBreite) then begin // innerer Pixel
- farben[i-xpmi+(j+oof)*breite].rgbRed:=0;
- farben[i-xpmi+(j+oof)*breite].rgbGreen:=0;
- farben[i-xpmi+(j+oof)*breite].rgbBlue:=0;
+ gibAus('Thread '+intToStr(nummer)+': Werte -> Bild ...',1);
+ for j:=-oOf to wHoehe-1+uOf do
+ for i:=xPMi to xPMa do
+ if (j>=0) and (j<wHoehe) and (i>=0) and (i<gesBreite) then begin // innerer Pixel
+ farben[i-xPMi+(j+oOf)*breite].rgbRed:=0;
+ farben[i-xPMi+(j+oOf)*breite].rgbGreen:=0;
+ farben[i-xPMi+(j+oOf)*breite].rgbBlue:=0;
for k:=0 to length(wertes)-1 do begin
- wert:=(wertes[k,i-max(0,xpmi)+j*wbreite]/anzahlens[k,i-max(0,xpmi)+j*wbreite]-ws[k]._minW)/(ws[k]._maxW-ws[k]._minW);
+ wert:=(wertes[k,i-max(0,xPMi)+j*wBreite]/anzahlens[k,i-max(0,xPMi)+j*wBreite]-ws[k]._minW)/(ws[k]._maxW-ws[k]._minW);
wert:=max(0,min(wert,1));
wert:=nbs[k].transformiereWert(wert);
frb:=wertZuFarbe(wert,pals[k]);
- with farben[i-xpmi+(j+oof)*breite] do begin // farben startet bei Index 0 + 0*breite
+ with farben[i-xPMi+(j+oOf)*breite] do begin // farben startet bei Index 0 + 0*breite
rgbRed:= rgbRed + frb.rgbRed;
rgbGreen:=rgbGreen + frb.rgbGreen;
rgbBlue:= rgbBlue + frb.rgbBlue;
@@ -5410,51 +5572,51 @@ begin
end;
end
else begin
- farben[i-xpmi+(j+oof)*breite].rgbRed:=
+ farben[i-xPMi+(j+oOf)*breite].rgbRed:=
$ff * byte((not rahmen) or
- ((not ((i=-1) and (j>=-1) and (j<=whoehe))) and // links
- (not ((i=gesBreite) and (j>=-1) and (j<=whoehe))) and // rechts
+ ((not ((i=-1) and (j>=-1) and (j<=wHoehe))) and // links
+ (not ((i=gesBreite) and (j>=-1) and (j<=wHoehe))) and // rechts
(not ((j=-1) and (i>=-1) and (i<=gesBreite))) and // oben
- (not ((j=whoehe) and (i>=-1) and (i<=gesBreite))))); // unten
- farben[i-xpmi+(j+oof)*breite].rgbGreen:=farben[i-xpmi+(j+oof)*breite].rgbRed;
- farben[i-xpmi+(j+oof)*breite].rgbBlue:=farben[i-xpmi+(j+oof)*breite].rgbRed;
+ (not ((j=wHoehe) and (i>=-1) and (i<=gesBreite))))); // unten
+ farben[i-xPMi+(j+oOf)*breite].rgbGreen:=farben[i-xPMi+(j+oOf)*breite].rgbRed;
+ farben[i-xPMi+(j+oOf)*breite].rgbBlue:=farben[i-xPMi+(j+oOf)*breite].rgbRed;
end;
- gibAus('Thread '+inttostr(nummer)+': Beschriftung einfügen ...',1);
+ gibAus('Thread '+intToStr(nummer)+': Beschriftung einfügen ...',1);
- for i:=0 to length(Beschr^)-1 do begin
- for j:=max(Beschr^[i].links,xpmi) to min(Beschr^[i].rechts,xpma) do
- for k:=Beschr^[i].oben to Beschr^[i].unten do
- farben[j-xpmi+(k+oof)*breite]:=
+ for i:=0 to length(beschr^)-1 do begin
+ for j:=max(beschr^[i].links,xPMi) to min(beschr^[i].rechts,xPMa) do
+ for k:=beschr^[i].oben to beschr^[i].unten do
+ farben[j-xPMi+(k+oOf)*breite]:=
andFarben(
- farben[j-xpmi+(k+oof)*breite],
- Beschr^[i].bild.farben[j-Beschr^[i].links + (k-Beschr^[i].oben)*Beschr^[i].bild.breite]);
- case Beschr^[i].lage of
+ farben[j-xPMi+(k+oOf)*breite],
+ beschr^[i].bild.farben[j-beschr^[i].links + (k-beschr^[i].oben)*beschr^[i].bild.breite]);
+ case beschr^[i].lage of
lRechts:
- for j:=max(Beschr^[i].bBreite,xpmi) to min(Beschr^[i].bBreite+3+byte(Rahmen),xpma) do begin
- farben[j-xpmi+(Beschr^[i].strich+oof)*breite].rgbRed:=$00;
- farben[j-xpmi+(Beschr^[i].strich+oof)*breite].rgbGreen:=$00;
- farben[j-xpmi+(Beschr^[i].strich+oof)*breite].rgbBlue:=$00;
+ for j:=max(beschr^[i].bBreite,xPMi) to min(beschr^[i].bBreite+3+byte(rahmen),xPMa) do begin
+ farben[j-xPMi+(beschr^[i].strich+oOf)*breite].rgbRed:=$00;
+ farben[j-xPMi+(beschr^[i].strich+oOf)*breite].rgbGreen:=$00;
+ farben[j-xPMi+(beschr^[i].strich+oOf)*breite].rgbBlue:=$00;
end;
lLinks:
- for j:=max(-4-byte(Rahmen),xpmi) to min(-1,xpma) do begin
- farben[j-xpmi+(Beschr^[i].strich+oof)*breite].rgbRed:=$00;
- farben[j-xpmi+(Beschr^[i].strich+oof)*breite].rgbGreen:=$00;
- farben[j-xpmi+(Beschr^[i].strich+oof)*breite].rgbBlue:=$00;
+ for j:=max(-4-byte(rahmen),xPMi) to min(-1,xPMa) do begin
+ farben[j-xPMi+(beschr^[i].strich+oOf)*breite].rgbRed:=$00;
+ farben[j-xPMi+(beschr^[i].strich+oOf)*breite].rgbGreen:=$00;
+ farben[j-xPMi+(beschr^[i].strich+oOf)*breite].rgbBlue:=$00;
end;
lOben:
- if (Beschr^[i].strich>=xpmi) and (Beschr^[i].strich<=xpma) then
- for j:=Beschr^[i].bHoehe to Beschr^[i].bHoehe+3+byte(Rahmen) do begin
- farben[Beschr^[i].strich-xpmi+(j+oof)*breite].rgbRed:=$00;
- farben[Beschr^[i].strich-xpmi+(j+oof)*breite].rgbGreen:=$00;
- farben[Beschr^[i].strich-xpmi+(j+oof)*breite].rgbBlue:=$00;
+ if (beschr^[i].strich>=xPMi) and (beschr^[i].strich<=xPMa) then
+ for j:=beschr^[i].bHoehe to beschr^[i].bHoehe+3+byte(rahmen) do begin
+ farben[beschr^[i].strich-xPMi+(j+oOf)*breite].rgbRed:=$00;
+ farben[beschr^[i].strich-xPMi+(j+oOf)*breite].rgbGreen:=$00;
+ farben[beschr^[i].strich-xPMi+(j+oOf)*breite].rgbBlue:=$00;
end;
lUnten:
- if (Beschr^[i].strich>=xpmi) and (Beschr^[i].strich<=xpma) then
- for j:=-4-byte(Rahmen) to -1 do begin
- farben[Beschr^[i].strich-xpmi+(j+oof)*breite].rgbRed:=$00;
- farben[Beschr^[i].strich-xpmi+(j+oof)*breite].rgbGreen:=$00;
- farben[Beschr^[i].strich-xpmi+(j+oof)*breite].rgbBlue:=$00;
+ if (beschr^[i].strich>=xPMi) and (beschr^[i].strich<=xPMa) then
+ for j:=-4-byte(rahmen) to -1 do begin
+ farben[beschr^[i].strich-xPMi+(j+oOf)*breite].rgbRed:=$00;
+ farben[beschr^[i].strich-xPMi+(j+oOf)*breite].rgbGreen:=$00;
+ farben[beschr^[i].strich-xPMi+(j+oOf)*breite].rgbBlue:=$00;
end;
end{of case};
end;
@@ -5467,14 +5629,14 @@ begin
wert:=wertes[k,0];
for i:=0 to length(wertes[k])-1 do
wert:=max(wert,wertes[k,i]);
- gibAus('Thread '+inttostr(nummer)+' hat max. ['+inttostr(k)+'] '+myfloattostr(wert),1);
+ gibAus('Thread '+intToStr(nummer)+' hat max. ['+intToStr(k)+'] '+myFloatToStr(wert),1);
for i:=0 to length(wertes[k])-1 do
wert:=min(wert,wertes[k,i]);
- gibAus('Thread '+inttostr(nummer)+' hat min. ['+inttostr(k)+'] '+myfloattostr(wert),1);
+ gibAus('Thread '+intToStr(nummer)+' hat min. ['+intToStr(k)+'] '+myFloatToStr(wert),1);
if not b then
- gibAus('Thread '+inttostr(nummer)+' hat nur Nullen!',1);
+ gibAus('Thread '+intToStr(nummer)+' hat nur Nullen!',1);
end;
- gibAus('Thread '+inttostr(nummer)+' fertig!',1);
+ gibAus('Thread '+intToStr(nummer)+' fertig!',1);
end;
procedure tBilderThread.initAnzahlensFuerKontur;
@@ -5482,35 +5644,35 @@ var
ii: longint;
begin
for ii:=1 to length(anzahlens)-1 do
- setlength(anzahlens[ii],0);
- setlength(anzahlens,1);
- setlength(anzahlens[0],length(farben));
+ setLength(anzahlens[ii],0);
+ setLength(anzahlens,1);
+ setLength(anzahlens[0],length(farben));
for ii:=0 to length(anzahlens[0])-1 do
anzahlens[0,ii]:=0;
end;
// tDichteThread ***************************************************************
-constructor tDichteThread.create(xmi,xma,tmi,tma: longint; const werte: tWerte);
+constructor tDichteThread.create(xMi,xMa,tMi,tMa: longint; const werte: tWerte);
begin
inherited create;
- xmin:=xmi;
- xmax:=xma;
- tmin:=tmi;
- tmax:=tma;
+ xMin:=xMi;
+ xMax:=xMa;
+ tMin:=tMi;
+ tMax:=tMa;
w:=werte;
- maxdichte:=0;
- gibAus('Dichtethread kreiert: '+inttostr(xmin)+'-'+inttostr(xmax)+' '+inttostr(tmin)+'-'+inttostr(tmax),1);
+ maxDichte:=0;
+ gibAus('Dichtethread kreiert: '+intToStr(xMin)+'-'+intToStr(xMax)+' '+intToStr(tMin)+'-'+intToStr(tMax),1);
suspended:=false;
end;
procedure tDichteThread.stExecute;
begin
gibAus('Dichtethread gestartet!',1);
- case w.Genauigkeit of
- gSingle: w.sWerte.gibMinMaxDichten(minDichte,maxDichte,xmin,xmax,tmin,tmax);
- gDouble: w.dWerte.gibMinMaxDichten(minDichte,maxDichte,xmin,xmax,tmin,tmax);
- gExtended: w.eWerte.gibMinMaxDichten(minDichte,maxDichte,xmin,xmax,tmin,tmax);
+ case w.genauigkeit of
+ gSingle: w.sWerte.gibMinMaxDichten(minDichte,maxDichte,xMin,xMax,tMin,tMax);
+ gDouble: w.dWerte.gibMinMaxDichten(minDichte,maxDichte,xMin,xMax,tMin,tMax);
+ gExtended: w.eWerte.gibMinMaxDichten(minDichte,maxDichte,xMin,xMax,tMin,tMax);
end{of case};
gibAus('Dichtethread fertig!',1);
end;
@@ -5519,12 +5681,16 @@ end;
constructor tFFTThread.create(werte: tWerte; smin,smax: longint; senkrecht,invers: boolean; const vor,nach: tFFTDatenordnung; fenster: tFenster; hintergrund: extended);
var
- tmpFFTAlgo: tFFTAlgorithmus;
+ tmpFFTAlgo: tFFTAlgorithmus;
+ halberInput: boolean;
begin
+ halberInput:=vor in [doAlleResIms,doAlleResSmi];
+ if halberInput and assigned(fenster) then
+ gibAus('Warnung: Diese Form der FFT ('+fftDoToStr(vor)+' -> '+fftDoToStr(nach)+') verhält sich beim Fenstern nicht so, wie man meinen möchte!',3);
if senkrecht then
- tmpFFTAlgo:=createFFTAlgorithmus(werte._tsiz,vor,nach)
+ tmpFFTAlgo:=createFFTAlgorithmus(werte._tSiz div (1+byte(halberInput)),vor,nach)
else
- tmpFFTAlgo:=createFFTAlgorithmus(werte._xsteps,vor,nach);
+ tmpFFTAlgo:=createFFTAlgorithmus(werte._xSteps div (1+byte(halberInput)),vor,nach);
create(werte,smin,smax,senkrecht,invers,tmpFFTAlgo,fenster,hintergrund);
tmpFFTAlgo.free;
end;
@@ -5541,14 +5707,14 @@ begin
fen:=fenster;
hg:=hintergrund;
erfolg:=false;
- gibAus('FFTthread kreiert ('+inttostr(pW._xsteps)+' x '+inttostr(pW._tsiz)+': '+inttostr(smi)+' .. '+inttostr(sma)+'): '+algo.className,3);
+ gibAus('FFTthread kreiert ('+intToStr(pW._xSteps)+' x '+intToStr(pW._tSiz)+': '+intToStr(smi)+' .. '+intToStr(sma)+'): '+algo.className,3);
suspended:=false;
end;
procedure tFFTThread.stExecute;
begin
- gibAus('FFTthread gestartet ('+inttostr(pW._xsteps)+' x '+inttostr(pW._tsiz)+': '+inttostr(smi)+' .. '+inttostr(sma)+'): '+algo.className+' ...',1);
- case pW.Genauigkeit of
+ gibAus('FFTthread gestartet ('+intToStr(pW._xSteps)+' x '+intToStr(pW._tSiz)+': '+intToStr(smi)+' .. '+intToStr(sma)+'): '+algo.className+' ...',1);
+ case pW.genauigkeit of
gSingle: erfolg:=pW.sWerte.fft(smi,sma,sen,inv,algo,fen,hg,pvFehler);
gDouble: erfolg:=pW.dWerte.fft(smi,sma,sen,inv,algo,fen,hg,pvFehler);
gExtended: erfolg:=pW.eWerte.fft(smi,sma,sen,inv,algo,fen,hg,pvFehler);
@@ -5558,20 +5724,20 @@ end;
// tSpiegelThread **************************************************************
-constructor tSpiegelThread.create(tmi,tma: longint; pWerte: tWerte);
+constructor tSpiegelThread.create(tMi,tMa: longint; pWerte: tWerte);
begin
inherited create;
- tmin:=tmi;
- tmax:=tma;
+ tMin:=tMi;
+ tMax:=tMa;
pW:=pWerte;;
- gibAus('Spiegelthread kreiert: '+inttostr(tmin)+'-'+inttostr(tmax),1);
+ gibAus('Spiegelthread kreiert: '+intToStr(tMin)+'-'+intToStr(tMax),1);
suspended:=false;
end;
procedure tSpiegelThread.stExecute;
begin
- gibAus('Spiegelthread gestartet: '+inttostr(tMin)+'-'+inttostr(tMax)+' ...',1);
- case pW.Genauigkeit of
+ gibAus('Spiegelthread gestartet: '+intToStr(tMin)+'-'+intToStr(tMax)+' ...',1);
+ case pW.genauigkeit of
gSingle: pW.sWerte.spiegle(tMin,tMax);
gDouble: pW.dWerte.spiegle(tMin,tMax);
gExtended: pW.eWerte.spiegle(tMin,tMax);
@@ -5581,24 +5747,24 @@ end;
// tFFT2dNBThread **************************************************************
-constructor tFFT2dNBThread.create(xmi,xma: longint; pWerte: tWerte; endordnung: tFFTDatenordnung);
+constructor tFFT2dNBThread.create(xMi,xMa: longint; pWerte: tWerte; endordnung: tFFTDatenordnung);
begin
inherited create;
- xmin:=xmi;
- xmax:=xma;
+ xMin:=xMi;
+ xMax:=xMa;
pW:=pWerte;
- nb:=endordnung;
- gibAus('FFT2d-Nachbearbeitungsthread kreiert: '+inttostr(xmin)+'-'+inttostr(xmax),1);
+ nB:=endordnung;
+ gibAus('FFT2d-Nachbearbeitungsthread kreiert: '+intToStr(xMin)+'-'+intToStr(xMax),1);
suspended:=false;
end;
procedure tFFT2dNBThread.stExecute;
begin
- gibAus('FFT2d-Nachbearbeitungsthread gestartet: '+inttostr(xMin)+'-'+inttostr(xMax)+' ...',1);
- case pW.Genauigkeit of
- gSingle: pW.sWerte.fft2dNachbearbeitungB(xMin,xMax,nb);
- gDouble: pW.dWerte.fft2dNachbearbeitungB(xMin,xMax,nb);
- gExtended: pW.eWerte.fft2dNachbearbeitungB(xMin,xMax,nb);
+ gibAus('FFT2d-Nachbearbeitungsthread gestartet: '+intToStr(xMin)+'-'+intToStr(xMax)+' ...',1);
+ case pW.genauigkeit of
+ gSingle: pW.sWerte.fft2dNachbearbeitungB(xMin,xMax,nB);
+ gDouble: pW.dWerte.fft2dNachbearbeitungB(xMin,xMax,nB);
+ gExtended: pW.eWerte.fft2dNachbearbeitungB(xMin,xMax,nB);
end{of case};
gibAus('... und fertig!',1);
end;
@@ -5636,14 +5802,14 @@ begin
maxBr:=maxBreite;
maxVersch:=maxVerschiebung;
posiMitten:=positionsMitten;
- gibAus('GaußFitThread kreiert: '+inttostr(von)+'-'+inttostr(bis),1);
+ gibAus('GaußFitThread kreiert: '+intToStr(von)+'-'+intToStr(bis),1);
suspended:=false;
end;
procedure tGauszFitThread.stExecute;
begin
gibAus('GaußFitThread gestartet ...',1);
- case qu.Genauigkeit of
+ case qu.genauigkeit of
gSingle:
qu.sWerte.gauszFit(ampl,br,posi,ueberl,hint,vo,bi,senkr,fenBr,maxBr,maxVersch,posiMitten);
gDouble:
@@ -5664,7 +5830,7 @@ begin
xMi:=xMin;
xMa:=xMax;
wl:=wavelet;
- gibAus('Korrelationsthread kreiert: '+inttostr(xmin)+'-'+inttostr(xmax),1);
+ gibAus('Korrelationsthread kreiert: '+intToStr(xMin)+'-'+intToStr(xMax),1);
suspended:=false;
end;
@@ -5677,117 +5843,117 @@ var
tmpFFTAlgo: tFFTAlgorithmus;
begin
gibAus('Korrelationsberechnungsthread gestartet ...',1);
- gibAus('('+inttostr(xmi)+'-'+inttostr(xma)+' x '+inttostr(qu._tsiz)+'), '+inttostr(wl.werte.params.tsiz),1);
+ gibAus('('+intToStr(xMi)+'-'+intToStr(xMa)+' x '+intToStr(qu._tSiz)+'), '+intToStr(wl.werte.params.tSiz),1);
in0:=true;
out0:=true;
pvFehler:=0;
if wl.mitFFT then begin
- for i:=xmi to xma do
- for j:=0 to qu._tsiz-1 do in0:=in0 and (zi.eWerte.werte[i+j*zi._xsteps]=0);
+ for i:=xMi to xMa do
+ for j:=0 to qu._tSiz-1 do in0:=in0 and (zi.eWerte.werte[i+j*zi._xSteps]=0);
gibAus('FFT berechnen ...',1);
- tmpFFTAlgo:=createFFTAlgorithmus(zi._tsiz,doRes,doResIms);
+ tmpFFTAlgo:=createFFTAlgorithmus(zi._tSiz,doRes,doResIms);
zi.eWerte.fft(true,false,tmpFFTAlgo,nil,0,pvF);
tmpFFTAlgo.free;
pvFehler:=pvF+pvFehler;
if wl.typ=wtSin2 then // Das Sin²-Wavelet besteht eigntlich aus zwei!
- tmpW:=tWerte.create(zi,xmi,xma);
+ tmpW:=tWerte.create(zi,xMi,xMa);
gibAus('... fertig, punktweise Produkte berechnen ...',1);
- hl:=qu._tsiz div 2; // halbe Länge
- for i:=xmi to xma do begin
+ hl:=qu._tSiz div 2; // halbe Länge
+ for i:=xMi to xMa do begin
zi.eWerte.werte[i]:=zi.eWerte.werte[i]*wl.werte.werte[0]; // f_0
- zi.eWerte.werte[i+hl*zi._xsteps]:=zi.eWerte.werte[i+hl*zi._xsteps]*wl.werte.werte[2*hl]; // f_n/2
+ zi.eWerte.werte[i+hl*zi._xSteps]:=zi.eWerte.werte[i+hl*zi._xSteps]*wl.werte.werte[2*hl]; // f_n/2
if wl.typ=wtSin2 then begin // Das Sin²-Wavelet besteht eigntlich aus zwei!
// und das gleiche für tmpW statt zi^:
- tmpW.eWerte.werte[i-xmi]:=tmpW.eWerte.werte[i-xmi]*wl.werte.werte[1]; // f_0
- tmpW.eWerte.werte[i-xmi+hl*tmpW._xsteps]:=tmpW.eWerte.werte[i-xmi+hl*tmpW._xsteps]*wl.werte.werte[2*hl+1]; // f_n/2
+ tmpW.eWerte.werte[i-xMi]:=tmpW.eWerte.werte[i-xMi]*wl.werte.werte[1]; // f_0
+ tmpW.eWerte.werte[i-xMi+hl*tmpW._xSteps]:=tmpW.eWerte.werte[i-xMi+hl*tmpW._xSteps]*wl.werte.werte[2*hl+1]; // f_n/2
end;
for j:=1 to hl-1 do begin
- tmp:=zi.eWerte.werte[i+j*zi._xsteps]; // Re_j
- zi.eWerte.werte[i+j*zi._xsteps]:=tmp*wl.werte.werte[2*j]-zi.eWerte.werte[i+(j+hl)*zi._xsteps]*wl.werte.werte[2*(j+hl)];
+ tmp:=zi.eWerte.werte[i+j*zi._xSteps]; // Re_j
+ zi.eWerte.werte[i+j*zi._xSteps]:=tmp*wl.werte.werte[2*j]-zi.eWerte.werte[i+(j+hl)*zi._xSteps]*wl.werte.werte[2*(j+hl)];
// Re_j * wRe_j - Im_j * wIm_j
- zi.eWerte.werte[i+(j+hl)*zi._xsteps]:=tmp*wl.werte.werte[2*(j+hl)]+zi.eWerte.werte[i+(j+hl)*zi._xsteps]*wl.werte.werte[2*j];
+ zi.eWerte.werte[i+(j+hl)*zi._xSteps]:=tmp*wl.werte.werte[2*(j+hl)]+zi.eWerte.werte[i+(j+hl)*zi._xSteps]*wl.werte.werte[2*j];
// Re_j * wIm_j + Im_j * wRe_j
if wl.typ=wtSin2 then begin // Das Sin²-Wavelet besteht eigntlich aus zwei!
// und das gleiche für tmpW statt zi^:
- tmp:=tmpW.eWerte.werte[i-xmi+j*tmpW._xsteps]; // Re_j
- tmpW.eWerte.werte[i-xmi+j*tmpW._xsteps]:=tmp*wl.werte.werte[2*j+1]-tmpW.eWerte.werte[i-xmi+(j+hl)*tmpW._xsteps]*wl.werte.werte[2*(j+hl)+1];
+ tmp:=tmpW.eWerte.werte[i-xMi+j*tmpW._xSteps]; // Re_j
+ tmpW.eWerte.werte[i-xMi+j*tmpW._xSteps]:=tmp*wl.werte.werte[2*j+1]-tmpW.eWerte.werte[i-xMi+(j+hl)*tmpW._xSteps]*wl.werte.werte[2*(j+hl)+1];
// Re_j * wRe_j - Im_j * wIm_j
- tmpW.eWerte.werte[i-xmi+(j+hl)*tmpW._xsteps]:=tmp*wl.werte.werte[2*(j+hl)+1]+tmpW.eWerte.werte[i-xmi+(j+hl)*tmpW._xsteps]*wl.werte.werte[2*j+1];
+ tmpW.eWerte.werte[i-xMi+(j+hl)*tmpW._xSteps]:=tmp*wl.werte.werte[2*(j+hl)+1]+tmpW.eWerte.werte[i-xMi+(j+hl)*tmpW._xSteps]*wl.werte.werte[2*j+1];
// Re_j * wIm_j + Im_j * wRe_j
end;
end;
end;
gibAus('... fertig, iFFT berechnen ...',1);
- tmpFFTAlgo:=createFFTAlgorithmus(zi._tsiz,doResIms,doBetrQdr);
- zi.eWerte.fft(xmi,xma,true,true,tmpFFTAlgo,nil,0,pvF);
+ tmpFFTAlgo:=createFFTAlgorithmus(zi._tSiz,doResIms,doBetrQdr);
+ zi.eWerte.fft(xMi,xMa,true,true,tmpFFTAlgo,nil,0,pvF);
pvFehler:=pvF+pvFehler;
case wl.typ of
wtSin2: begin // Das Sin²-Wavelet besteht eigntlich aus zwei!
tmpW.eWerte.fft(true,true,tmpFFTAlgo,nil,0,pvF);
pvFehler:=(pvF+pvFehler)/3;
- for i:=xmi to xma do
- for j:=0 to zi._tsiz-1 do begin
- zi.eWerte.werte[i+j*zi._xsteps]:=zi.eWerte.werte[i+j*zi._xsteps]+tmpW.eWerte.werte[i-xmi+j*tmpW._xsteps];
- out0:=out0 and (zi.eWerte.werte[i+j*zi._xsteps]=0);
+ for i:=xMi to xMa do
+ for j:=0 to zi._tSiz-1 do begin
+ zi.eWerte.werte[i+j*zi._xSteps]:=zi.eWerte.werte[i+j*zi._xSteps]+tmpW.eWerte.werte[i-xMi+j*tmpW._xSteps];
+ out0:=out0 and (zi.eWerte.werte[i+j*zi._xSteps]=0);
end;
tmpW.free;
end;
wtFrequenzfenster: begin // Das Frequenzfenster-Wavelet ist nur eines!
pvFehler:=pvFehler/2;
- for i:=xmi to xma do
- for j:=0 to zi._tsiz-1 do
- out0:=out0 and (zi.eWerte.werte[i+j*zi._xsteps]=0);
+ for i:=xMi to xMa do
+ for j:=0 to zi._tSiz-1 do
+ out0:=out0 and (zi.eWerte.werte[i+j*zi._xSteps]=0);
end;
end{of case};
tmpFFTAlgo.free;
- gibAus(' (Parseval-Fehler = '+floattostr(pvFehler)+')',1);
+ gibAus(' (Parseval-Fehler = '+floatToStr(pvFehler)+')',1);
gibAus('... fertig',1);
end
else begin
- case qu.Genauigkeit of
+ case qu.genauigkeit of
gSingle:
- for i:=xmi to xma do begin
- if (xma-i) mod ((xma-xmi) div 10) = 0 then gibAus(inttostr(i)+'/'+inttostr(xmi)+'-'+inttostr(xma),1);
- for j:=0 to zi._tsiz-1 do begin
+ for i:=xMi to xMa do begin
+ if (xMa-i) mod ((xMa-xMi) div 10) = 0 then gibAus(intToStr(i)+'/'+intToStr(xMi)+'-'+intToStr(xMa),1);
+ for j:=0 to zi._tSiz-1 do begin
sus:=0;
suc:=0;
- for k:=max(-wl.hlen,-j) to min(wl.hlen,qu._tsiz-j-1) do begin
- suc:=suc + qu.sWerte.werte[i+(j+k)*qu._xsteps]*wl.werte.werte[(k+wl.hlen)*2];
- sus:=sus + qu.sWerte.werte[i+(j+k)*qu._xsteps]*wl.werte.werte[(k+wl.hlen)*2+1];
+ for k:=max(-wl.hLen,-j) to min(wl.hLen,qu._tSiz-j-1) do begin
+ suc:=suc + qu.sWerte.werte[i+(j+k)*qu._xSteps]*wl.werte.werte[(k+wl.hLen)*2];
+ sus:=sus + qu.sWerte.werte[i+(j+k)*qu._xSteps]*wl.werte.werte[(k+wl.hLen)*2+1];
end;
- zi.eWerte.werte[i+j*zi._xsteps]:=(sqr(sus)+sqr(suc))/sqr(1+2*wl.hlen);
- in0:=in0 and (qu.sWerte.werte[i+j*qu._xsteps]=0);
- out0:=out0 and (zi.eWerte.werte[i+j*zi._xsteps]=0);
+ zi.eWerte.werte[i+j*zi._xSteps]:=(sqr(sus)+sqr(suc))/sqr(1+2*wl.hLen);
+ in0:=in0 and (qu.sWerte.werte[i+j*qu._xSteps]=0);
+ out0:=out0 and (zi.eWerte.werte[i+j*zi._xSteps]=0);
end;
end;
gDouble:
- for i:=xmi to xma do begin
- if (xma-i) mod ((xma-xmi) div 10) = 0 then gibAus(inttostr(i)+'/'+inttostr(xmi)+'-'+inttostr(xma),1);
- for j:=0 to zi._tsiz-1 do begin
+ for i:=xMi to xMa do begin
+ if (xMa-i) mod ((xMa-xMi) div 10) = 0 then gibAus(intToStr(i)+'/'+intToStr(xMi)+'-'+intToStr(xMa),1);
+ for j:=0 to zi._tSiz-1 do begin
sus:=0;
suc:=0;
- for k:=max(-wl.hlen,-j) to min(wl.hlen,qu._tsiz-j-1) do begin
- suc:=suc + qu.dWerte.werte[i+(j+k)*qu._xsteps]*wl.werte.werte[(k+wl.hlen)*2];
- sus:=sus + qu.dWerte.werte[i+(j+k)*qu._xsteps]*wl.werte.werte[(k+wl.hlen)*2+1];
+ for k:=max(-wl.hLen,-j) to min(wl.hLen,qu._tSiz-j-1) do begin
+ suc:=suc + qu.dWerte.werte[i+(j+k)*qu._xSteps]*wl.werte.werte[(k+wl.hLen)*2];
+ sus:=sus + qu.dWerte.werte[i+(j+k)*qu._xSteps]*wl.werte.werte[(k+wl.hLen)*2+1];
end;
- zi.eWerte.werte[i+j*zi._xsteps]:=(sqr(sus)+sqr(suc))/sqr(1+2*wl.hlen);
- in0:=in0 and (qu.dWerte.werte[i+j*qu._xsteps]=0);
- out0:=out0 and (zi.eWerte.werte[i+j*zi._xsteps]=0);
+ zi.eWerte.werte[i+j*zi._xSteps]:=(sqr(sus)+sqr(suc))/sqr(1+2*wl.hLen);
+ in0:=in0 and (qu.dWerte.werte[i+j*qu._xSteps]=0);
+ out0:=out0 and (zi.eWerte.werte[i+j*zi._xSteps]=0);
end;
end;
gExtended:
- for i:=xmi to xma do begin
- if (xma-i) mod ((xma-xmi) div 10) = 0 then gibAus(inttostr(i)+'/'+inttostr(xmi)+'-'+inttostr(xma),1);
- for j:=0 to zi._tsiz-1 do begin
+ for i:=xMi to xMa do begin
+ if (xMa-i) mod ((xMa-xMi) div 10) = 0 then gibAus(intToStr(i)+'/'+intToStr(xMi)+'-'+intToStr(xMa),1);
+ for j:=0 to zi._tSiz-1 do begin
sus:=0;
suc:=0;
- for k:=max(-wl.hlen,-j) to min(wl.hlen,qu._tsiz-j-1) do begin
- suc:=suc + qu.eWerte.werte[i+(j+k)*qu._xsteps]*wl.werte.werte[(k+wl.hlen)*2];
- sus:=sus + qu.eWerte.werte[i+(j+k)*qu._xsteps]*wl.werte.werte[(k+wl.hlen)*2+1];
+ for k:=max(-wl.hLen,-j) to min(wl.hLen,qu._tSiz-j-1) do begin
+ suc:=suc + qu.eWerte.werte[i+(j+k)*qu._xSteps]*wl.werte.werte[(k+wl.hLen)*2];
+ sus:=sus + qu.eWerte.werte[i+(j+k)*qu._xSteps]*wl.werte.werte[(k+wl.hLen)*2+1];
end;
- zi.eWerte.werte[i+j*zi._xsteps]:=(sqr(sus)+sqr(suc))/sqr(1+2*wl.hlen);
- in0:=in0 and (qu.eWerte.werte[i+j*qu._xsteps]=0);
- out0:=out0 and (zi.eWerte.werte[i+j*zi._xsteps]=0);
+ zi.eWerte.werte[i+j*zi._xSteps]:=(sqr(sus)+sqr(suc))/sqr(1+2*wl.hLen);
+ in0:=in0 and (qu.eWerte.werte[i+j*qu._xSteps]=0);
+ out0:=out0 and (zi.eWerte.werte[i+j*zi._xSteps]=0);
end;
end;
end{of case};
@@ -5799,16 +5965,16 @@ end;
// tKontur *********************************************************************
-constructor tKontur.create(Kont: pTKonturenArray; wert: pTWerteArray);
+constructor tKontur.create(kont: pTKonturenArray; wert: pTWerteArray);
begin
- inherited create(Kont,wert);
- setlength(orte,0);
+ inherited create(kont,wert);
+ setLength(orte,0);
bezeichner:='';
end;
destructor tKontur.destroy;
begin
- setlength(orte,0);
+ setLength(orte,0);
inherited destroy;
end;
@@ -5864,23 +6030,23 @@ begin
result:=max(result,orte[i]['y']);
end;
-function tKontur.exprtofloat(st: boolean; s: string; kvs: tKnownValues): extended;
+function tKontur.exprToFloat(sT: boolean; s: string; kvs: tKnownValues): extended;
begin
- result:=matheunit.exprtofloat(st,s,kvs,@callBackGetValue);
+ result:=matheunit.exprToFloat(sT,s,kvs,@callBackGetValue);
end;
-function tKontur.init(st: boolean; 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;
+ s,xMi,xMa,tMi,tMa,dx,dt: string;
i,j,k: longint;
bekannteBefehle: tMyStringList;
begin
result:=false;
gibAus('Kontur erzeugen ...',1);
- xmi:='-1e9';
- xma:='1e9';
- tmi:='-1e9';
- tma:='1e9';
+ xMi:='-1e9';
+ xMa:='1e9';
+ tMi:='-1e9';
+ tMa:='1e9';
dx:='1';
dt:='1';
bekannteBefehle:=tMyStringList.create;
@@ -5896,7 +6062,7 @@ begin
bekannteBefehle.free;
exit;
end;
- if not liesVonDatei(st,s,exprtofloat(st,xmi,nil),exprtofloat(st,xma,nil),exprtofloat(st,tmi,nil),exprtofloat(st,tma,nil)) then begin
+ if not liesVonDatei(sT,s,exprToFloat(sT,xMi,nil),exprToFloat(sT,xMa,nil),exprToFloat(sT,tMi,nil),exprToFloat(sT,tMa,nil)) then begin
bekannteBefehle.free;
exit;
end;
@@ -5908,26 +6074,26 @@ begin
bekannteBefehle.free;
exit;
end;
- if not erzeugeAusWerten(st,s,w,mt,xmi,xma,tmi,tma) then begin
+ if not erzeugeAusWerten(sT,s,w,mT,xMi,xMa,tMi,tMa) then begin
bekannteBefehle.free;
exit;
end;
continue;
end;
- if istDasBefehl('xmin:',s,bekannteBefehle,true) then begin
- xmi:=s;
+ if istDasBefehl('xMin:',s,bekannteBefehle,true) then begin
+ xMi:=s;
continue;
end;
- if istDasBefehl('xmax:',s,bekannteBefehle,true) then begin
- xma:=s;
+ if istDasBefehl('xMax:',s,bekannteBefehle,true) then begin
+ xMa:=s;
continue;
end;
- if istDasBefehl('tmin:',s,bekannteBefehle,true) then begin
- tmi:=s;
+ if istDasBefehl('tMin:',s,bekannteBefehle,true) then begin
+ tMi:=s;
continue;
end;
- if istDasBefehl('tmax:',s,bekannteBefehle,true) then begin
- tma:=s;
+ if istDasBefehl('tMax:',s,bekannteBefehle,true) then begin
+ tMa:=s;
continue;
end;
if istDasBefehl('dx:',s,bekannteBefehle,true) then begin
@@ -5939,8 +6105,8 @@ begin
continue;
end;
if istDasBefehl('reduziere nach',s,bekannteBefehle,true) then begin
- if not st then
- if not sortiere_nach_y(mt) then begin
+ if not sT then
+ if not sortiereNachY(mT) then begin
bekannteBefehle.free;
exit;
end;
@@ -5948,33 +6114,33 @@ begin
if istDasBefehl('rechts',s,bekannteBefehle,false) then begin
i:=0;
j:=0;
- while j<length(Orte) do begin
+ while j<length(orte) do begin
k:=j;
- while (j<length(Orte)) and (Orte[j]['y']=Orte[k]['y']) do begin
- if Orte[j]['x']>Orte[k]['x'] then
+ while (j<length(orte)) and (orte[j]['y']=orte[k]['y']) do begin
+ if orte[j]['x']>orte[k]['x'] then
k:=j;
inc(j);
end;
- Orte[i]:=Orte[k];
+ orte[i]:=orte[k];
inc(i);
end;
- setlength(Orte,i);
+ setLength(orte,i);
continue;
end;
if istDasBefehl('links',s,bekannteBefehle,false) then begin
i:=0;
j:=0;
- while j<length(Orte) do begin
+ while j<length(orte) do begin
k:=j;
- while (j<length(Orte)) and (Orte[j]['y']=Orte[k]['y']) do begin
- if Orte[j]['x']<Orte[k]['x'] then
+ while (j<length(orte)) and (orte[j]['y']=orte[k]['y']) do begin
+ if orte[j]['x']<orte[k]['x'] then
k:=j;
inc(j);
end;
- Orte[i]:=Orte[k];
+ orte[i]:=orte[k];
inc(i);
end;
- setlength(Orte,i);
+ setLength(orte,i);
continue;
end;
bekannteBefehle.sort;
@@ -5984,15 +6150,15 @@ begin
end;
if istDasBefehl('Funktion:',s,bekannteBefehle,true) then begin
if not erzeugeAusFunktion(
- st,
+ sT,
s,
- exprtofloat(st,xmi,nil),
- exprtofloat(st,xma,nil),
- exprtofloat(st,tmi,nil),
- exprtofloat(st,tma,nil),
- exprtofloat(st,dx,nil),
- exprtofloat(st,dt,nil),
- mt) then begin
+ exprToFloat(sT,xMi,nil),
+ exprToFloat(sT,xMa,nil),
+ exprToFloat(sT,tMi,nil),
+ exprToFloat(sT,tMa,nil),
+ exprToFloat(sT,dx,nil),
+ exprToFloat(sT,dt,nil),
+ mT) then begin
bekannteBefehle.free;
exit;
end;
@@ -6005,11 +6171,11 @@ begin
exit;
until false;
bekannteBefehle.free;
- gibAus('... fertig ('+inttostr(length(Orte))+' Punkte)',1);
+ gibAus('... fertig ('+intToStr(length(orte))+' Punkte)',1);
result:=true;
end;
-function tKontur.liesVonDatei(st: boolean; s: string; xmi,xma,tmi,tma: extended): boolean;
+function tKontur.liesVonDatei(sT: boolean; s: string; xMi,xMa,tMi,tMa: extended): boolean;
var
tf: textfile;
i: longint;
@@ -6020,84 +6186,84 @@ begin
gibAus('Datei '''+s+''' zum Einlesen einer Kontur existiert nicht!',3);
exit;
end;
- if st then begin
+ if sT then begin
result:=true;
exit;
end;
i:=0;
- assignfile(tf,s);
+ assignFile(tf,s);
reset(tf);
while not eof(tf) do begin
readln(tf,s);
s:=erstesArgument(s,'#');
if s='' then continue;
- tmp['y']:=strtofloat(erstesArgument(s));
- tmp['x']:=strtofloat(erstesArgument(s));
- if (tmp['x']<xmi) or (tmp['x']>xma) or (tmp['y']<tmi) or (tmp['y']>tma) then continue;
+ tmp['y']:=strToFloat(erstesArgument(s));
+ tmp['x']:=strToFloat(erstesArgument(s));
+ if (tmp['x']<xMi) or (tmp['x']>xMa) or (tmp['y']<tMi) or (tmp['y']>tMa) then continue;
if i>=length(orte) then
- setlength(orte,length(orte)+Speicherhappen);
+ setLength(orte,length(orte)+speicherHappen);
orte[i]:=tmp;
inc(i);
end;
- closefile(tf);
- setlength(orte,i);
+ closeFile(tf);
+ setLength(orte,i);
result:=true;
end;
-function tKontur.erzeugeAusWerten(st: boolean; s: string; w: pTWerteArray; mt: longint; _xmin,_xmax,_tmin,_tmax: string): boolean;
+function tKontur.erzeugeAusWerten(sT: boolean; s: string; w: pTWerteArray; mT: longint; _xmin,_xmax,_tmin,_tmax: string): boolean;
var
- i,j,k,l,xmi,xma,tmi,tma: longint;
- Schwelle: extended;
+ i,j,k,l,xMi,xMa,tMi,tMa: longint;
+ schwelle: extended;
fertig: boolean;
- Konturthreads: array of tKonturAusWertenThread;
+ konturThreads: array of tKonturAusWertenThread;
begin
result:=false;
i:=findeWerte(erstesArgument(s),nil,w,nil,false);
if i<0 then exit;
- Schwelle:=w^[i].exprtofloat(false,s);
- if _xmin='' then xmi:=1
- else xmi:=max(1,w^[i].kont2disk('x',w^[i].exprtofloat(st,_xmin)));
- if _xmax='' then xma:=w^[i]._xsteps-1
- else xma:=max(1,w^[i].kont2disk('x',w^[i].exprtofloat(st,_xmax)));
- if _tmin='' then tmi:=1
- else tmi:=max(1,w^[i].kont2disk('t',w^[i].exprtofloat(st,_tmin)));
- if _tmax='' then tma:=w^[i]._tsiz-1
- else tma:=max(1,w^[i].kont2disk('x',w^[i].exprtofloat(st,_tmax)));
- if st then begin
+ schwelle:=w^[i].exprToFloat(false,s);
+ if _xmin='' then xMi:=1
+ else xMi:=max(1,w^[i].kont2disk('x',w^[i].exprToFloat(sT,_xmin)));
+ if _xmax='' then xMa:=w^[i]._xSteps-1
+ else xMa:=max(1,w^[i].kont2disk('x',w^[i].exprToFloat(sT,_xmax)));
+ if _tmin='' then tMi:=1
+ else tMi:=max(1,w^[i].kont2disk('t',w^[i].exprToFloat(sT,_tmin)));
+ if _tmax='' then tMa:=w^[i]._tSiz-1
+ else tMa:=max(1,w^[i].kont2disk('x',w^[i].exprToFloat(sT,_tmax)));
+ if sT then begin
result:=true;
exit;
end;
- setlength(Konturthreads,mt);
- for j:=0 to length(Konturthreads)-1 do
- Konturthreads[j]:=
+ setLength(konturThreads,mT);
+ for j:=0 to length(konturThreads)-1 do
+ konturThreads[j]:=
tKonturAusWertenThread.create(
w^[i],
- Schwelle,
- round(j/length(Konturthreads)*(xma+1-xmi)+xmi),
- round((j+1)/length(Konturthreads)*(xma+1-xmi)+xmi-1),
- tmi,
- tma);
+ schwelle,
+ round(j/length(konturThreads)*(xMa+1-xMi)+xMi),
+ round((j+1)/length(konturThreads)*(xMa+1-xMi)+xMi-1),
+ tMi,
+ tMa);
repeat
fertig:=true;
- for j:=0 to length(Konturthreads)-1 do
- fertig:=fertig and Konturthreads[j].fertig;
+ for j:=0 to length(konturThreads)-1 do
+ fertig:=fertig and konturThreads[j].fertig;
if not fertig then sleep(10);
until fertig;
k:=0;
- for j:=0 to length(Konturthreads)-1 do
- k:=k+length(Konturthreads[j].punkte);
- setlength(orte,k);
+ for j:=0 to length(konturThreads)-1 do
+ k:=k+length(konturThreads[j].punkte);
+ setLength(orte,k);
k:=0;
- for j:=0 to length(Konturthreads)-1 do begin
- for l:=0 to length(Konturthreads[j].punkte)-1 do
- orte[k+l]:=Konturthreads[j].punkte[l];
- k:=k+length(Konturthreads[j].punkte);
- Konturthreads[j].Free;
+ for j:=0 to length(konturThreads)-1 do begin
+ for l:=0 to length(konturThreads[j].punkte)-1 do
+ orte[k+l]:=konturThreads[j].punkte[l];
+ k:=k+length(konturThreads[j].punkte);
+ konturThreads[j].free;
end;
result:=true;
end;
-function tKontur.erzeugeAusFunktion(st: boolean; s: string; xmi,xma,tmi,tma,dx,dt: extended; mt: longint): boolean;
+function tKontur.erzeugeAusFunktion(sT: boolean; s: string; xMi,xMa,tMi,tMa,dx,dt: extended; mT: longint): boolean;
var
xf,yf: string;
kvs: tKnownValues;
@@ -6108,8 +6274,8 @@ var
procedure berechnePOrt(i: longint); inline;
begin
kvs.add(s,pOrte[i,0]);
- pOrte[i,1]:=exprToFloat(st,xf,kvs);
- pOrte[i,2]:=exprToFloat(st,yf,kvs);
+ pOrte[i,1]:=exprToFloat(sT,xf,kvs);
+ pOrte[i,2]:=exprToFloat(sT,yf,kvs);
end;
function pOIndexInnerhalb(i: longint): boolean; inline;
@@ -6119,7 +6285,7 @@ end;
function liegtInnerhalb(i: longint): boolean; inline;
begin
- result:=pOIndexInnerhalb(i) and (pOrte[i,1]>=xmi) and (pOrte[i,1]<=xma) and (pOrte[i,2]>=tmi) and (pOrte[i,2]<=tma);
+ result:=pOIndexInnerhalb(i) and (pOrte[i,1]>=xMi) and (pOrte[i,1]<=xMa) and (pOrte[i,2]>=tMi) and (pOrte[i,2]<=tMa);
end;
function punkteFastGleich(i1,i2: longint): boolean; inline;
@@ -6145,27 +6311,27 @@ begin
kvs:=tKnownValues.create;
lenPO:=1;
- setlength(pOrte,speicherHappen);
+ setLength(pOrte,speicherHappen);
pOrte[0,0]:=0;
berechnePOrt(0);
- if st then begin
+ if sT then begin
result:=true;
kvs.free;
- setlength(pOrte,0);
+ setLength(pOrte,0);
exit;
end;
if not liegtInnerhalb(0) then begin
- gibAus('Die Funktionen '''+xf+''' bzw. '''+yf+''' erzeugen für '''+s+'''=0 keinen Punkt innerhalb der Grenzen ('+floattostr(xmi)+'..'+floattostr(xma)+' x '+floattostr(tmi)+'..'+floattostr(tma)+')!',3);
+ gibAus('Die Funktionen '''+xf+''' bzw. '''+yf+''' erzeugen für '''+s+'''=0 keinen Punkt innerhalb der Grenzen ('+floatToStr(xMi)+'..'+floatToStr(xMa)+' x '+floatToStr(tMi)+'..'+floatToStr(tMa)+')!',3);
kvs.free;
- setlength(pOrte,0);
+ setLength(pOrte,0);
exit;
end;
lenB:=2;
- setlength(baustellen,speicherHappen);
+ setLength(baustellen,speicherHappen);
baustellen[0,'x']:=low(longint);
baustellen[0,'y']:=0;
baustellen[1,'x']:=0;
@@ -6177,9 +6343,9 @@ begin
continue;
end;
if length(baustellen)<=lenB+1 then
- setlength(baustellen,lenB+speicherHappen);
+ setLength(baustellen,lenB+speicherHappen);
if length(pOrte)<=lenPO+2 then
- setlength(pOrte,lenPO+speicherHappen);
+ setLength(pOrte,lenPO+speicherHappen);
inc(lenPO);
if baustellen[lenB-1,'x']=low(longint) then
@@ -6222,15 +6388,15 @@ begin
end{of case};
end;
- setlength(orte,lenPO);
+ setLength(orte,lenPO);
for i:=0 to lenPO-1 do begin
orte[i,'x']:=i;
orte[i,'y']:=pOrte[i,0];
end;
- if not sortiere_nach_y(mt) then begin
- setlength(baustellen,0);
- setlength(pOrte,0);
+ if not sortiereNachY(mT) then begin
+ setLength(baustellen,0);
+ setLength(pOrte,0);
kvs.free;
exit;
end;
@@ -6240,23 +6406,23 @@ begin
orte[i,'x']:=pOrte[round(orte[i,'x']),1];
end;
- setlength(baustellen,0);
- setlength(pOrte,0);
+ setLength(baustellen,0);
+ setLength(pOrte,0);
kvs.free;
result:=true;
end;
-function tKontur.sortiere_nach_y(mt: longint): boolean;
+function tKontur.sortiereNachY(mT: longint): boolean;
begin
- result:=sortiere_nach_y(mt,0,length(Orte)-1);
+ result:=sortiereNachY(mT,0,length(orte)-1);
end;
-function tKontur.sortiere_nach_y(mt,von,bis: longint): boolean;
+function tKontur.sortiereNachY(mT,von,bis: longint): boolean;
var
i,j: longint;
avg: extended;
tmp: tExtPoint;
- st1,st2: tSortiereNachYThread;
+ sT1,sT2: tSortiereNachYThread;
begin
result:=false;
if von>=bis then begin
@@ -6265,29 +6431,29 @@ begin
end;
avg:=0;
for i:=von to bis do
- avg:=avg+Orte[i]['y'];
+ avg:=avg+orte[i]['y'];
avg:=avg/(bis-von+1);
i:=von;
j:=bis;
while i<j do begin
- while (i<=j) and (Orte[i]['y']<=avg) do
+ while (i<=j) and (orte[i]['y']<=avg) do
inc(i);
- while (i<=j) and (Orte[j]['y']>=avg) do
+ while (i<=j) and (orte[j]['y']>=avg) do
dec(j);
if i<j then begin
- tmp:=Orte[i];
- Orte[i]:=Orte[j];
- Orte[j]:=tmp;
+ tmp:=orte[i];
+ orte[i]:=orte[j];
+ orte[j]:=tmp;
end;
end;
if i<>j+1 then begin
- gibAus(' interner Quicksort-Fehler: "quicksort-sanity-check nicht bestanden! (i='+inttostr(i)+' & j='+inttostr(j)+')"',1);
+ gibAus(' interner Quicksort-Fehler: "quicksort-sanity-check nicht bestanden! (i='+intToStr(i)+' & j='+intToStr(j)+')"',1);
exit;
end;
if (j<von) or (i>bis) then begin
for i:=von+1 to bis do
- if Orte[i]['y'] <> Orte[von]['y'] then begin
+ if orte[i]['y'] <> orte[von]['y'] then begin
gibAus(' interner Quicksort-Fehler: "komisch, die Orte sind doch unterschiedlich ..."',1);
exit;
end;
@@ -6295,64 +6461,64 @@ begin
exit;
end;
- if mt<=1 then
- result:=sortiere_nach_y(mt,von,i-1) and sortiere_nach_y(mt,i,bis)
+ if mT<=1 then
+ result:=sortiereNachY(mT,von,i-1) and sortiereNachY(mT,i,bis)
else begin
- j:=min(max(1,round(mt/(bis+1-von)*(i-von))),mt-1);
- st1:=tSortiereNachYThread.create(self,j,von,i-1);
- st2:=tSortiereNachYThread.create(self,mt-j,i,bis);
+ j:=min(max(1,round(mT/(bis+1-von)*(i-von))),mT-1);
+ sT1:=tSortiereNachYThread.create(self,j,von,i-1);
+ sT2:=tSortiereNachYThread.create(self,mT-j,i,bis);
repeat
sleep(10);
- until st1.fertig and st2.fertig;
- result:=st1.erfolg and st2.erfolg;
- st1.free;
- st2.free;
+ until sT1.fertig and sT2.fertig;
+ result:=sT1.erfolg and sT2.erfolg;
+ sT1.free;
+ sT2.free;
end;
end;
// tKonturAusWertenThread ******************************************************
-constructor tKonturAusWertenThread.create(werte: tWerte; schwelle: extended; xmin, xmax, tmin, tmax: longint);
+constructor tKonturAusWertenThread.create(werte: tWerte; schwelle: extended; xMin, xMax, tMin, tMax: longint);
begin
inherited create;
w:=werte;
s:=schwelle;
- xmi:=xmin;
- xma:=xmax;
- tmi:=tmin;
- tma:=tmax;
- setlength(punkte,0);
+ xMi:=xMin;
+ xMa:=xMax;
+ tMi:=tMin;
+ tMa:=tMax;
+ setLength(punkte,0);
suspended:=false;
end;
destructor tKonturAusWertenThread.destroy;
begin
- setlength(punkte,0);
+ setLength(punkte,0);
inherited destroy;
end;
procedure tKonturAusWertenThread.stExecute;
begin
- case w.Genauigkeit of
- gSingle: punkte:=w.sWerte.findeSchwellwerte(xmi,xma,tmi,tma,s);
- gDouble: punkte:=w.dWerte.findeSchwellwerte(xmi,xma,tmi,tma,s);
- gExtended: punkte:=w.eWerte.findeSchwellwerte(xmi,xma,tmi,tma,s);
+ case w.genauigkeit of
+ gSingle: punkte:=w.sWerte.findeSchwellwerte(xMi,xMa,tMi,tMa,s);
+ gDouble: punkte:=w.dWerte.findeSchwellwerte(xMi,xMa,tMi,tMa,s);
+ gExtended: punkte:=w.eWerte.findeSchwellwerte(xMi,xMa,tMi,tMa,s);
end{of case};
end;
// tIntegralThread *************************************************************
-constructor tIntegralThread.create(quelle, ziel: tWerte; xmin, xmax, tmin, tmax, xoff, toff: longint; richtung: tIntegrationsRichtung);
+constructor tIntegralThread.create(quelle, ziel: tWerte; xMin, xMax, tMin, tMax, xOff, tOff: longint; richtung: tIntegrationsRichtung);
begin
inherited create;
qu:=quelle;
zi:=ziel;
- xmi:=xmin;
- xma:=xmax;
- tmi:=tmin;
- tma:=tmax;
- xof:=xoff;
- tof:=toff;
+ xMi:=xMin;
+ xMa:=xMax;
+ tMi:=tMin;
+ tMa:=tMax;
+ xOf:=xOff;
+ tOf:=tOff;
rtg:=richtung;
gibAus('Integralthread kreiert',1);
suspended:=false;
@@ -6360,33 +6526,33 @@ end;
procedure tIntegralThread.stExecute;
begin
- gibAus('Integralthread gestartet ('+inttostr(xmi)+'-'+inttostr(xma)+'x'+inttostr(tmi)+'-'+inttostr(tma)+') '+
- '('+inttostr(qu._xsteps)+'x'+inttostr(qu._tsiz)+') -> '+
- '('+inttostr(zi._xsteps)+'x'+inttostr(zi._tsiz)+') delta: '+
- inttostr(xof)+'x'+inttostr(tof)+' ...',1);
+ gibAus('Integralthread gestartet ('+intToStr(xMi)+'-'+intToStr(xMa)+'x'+intToStr(tMi)+'-'+intToStr(tMa)+') '+
+ '('+intToStr(qu._xSteps)+'x'+intToStr(qu._tSiz)+') -> '+
+ '('+intToStr(zi._xSteps)+'x'+intToStr(zi._tSiz)+') delta: '+
+ intToStr(xOf)+'x'+intToStr(tOf)+' ...',1);
case rtg of
irHorizontal: gibAus(' (horizontal)',1);
irEinfall: gibAus(' (einfallend)',1);
irAusfall: gibAus(' (ausfallend)',1);
end{of case};
- case zi.Genauigkeit of
+ case zi.genauigkeit of
gSingle:
- case qu.Genauigkeit of
- gSingle: zi.sWerte.integriereSingle(@(qu.sWerte),xmi,xma,tmi,tma,xof,tof,rtg);
- gDouble: zi.sWerte.integriereDouble(@(qu.dWerte),xmi,xma,tmi,tma,xof,tof,rtg);
- gExtended: zi.sWerte.integriereExtended(@(qu.eWerte),xmi,xma,tmi,tma,xof,tof,rtg);
+ case qu.genauigkeit of
+ gSingle: zi.sWerte.integriereSingle(@(qu.sWerte),xMi,xMa,tMi,tMa,xOf,tOf,rtg);
+ gDouble: zi.sWerte.integriereDouble(@(qu.dWerte),xMi,xMa,tMi,tMa,xOf,tOf,rtg);
+ gExtended: zi.sWerte.integriereExtended(@(qu.eWerte),xMi,xMa,tMi,tMa,xOf,tOf,rtg);
end{of case};
gDouble:
- case qu.Genauigkeit of
- gSingle: zi.dWerte.integriereSingle(@(qu.sWerte),xmi,xma,tmi,tma,xof,tof,rtg);
- gDouble: zi.dWerte.integriereDouble(@(qu.dWerte),xmi,xma,tmi,tma,xof,tof,rtg);
- gExtended: zi.dWerte.integriereExtended(@(qu.eWerte),xmi,xma,tmi,tma,xof,tof,rtg);
+ case qu.genauigkeit of
+ gSingle: zi.dWerte.integriereSingle(@(qu.sWerte),xMi,xMa,tMi,tMa,xOf,tOf,rtg);
+ gDouble: zi.dWerte.integriereDouble(@(qu.dWerte),xMi,xMa,tMi,tMa,xOf,tOf,rtg);
+ gExtended: zi.dWerte.integriereExtended(@(qu.eWerte),xMi,xMa,tMi,tMa,xOf,tOf,rtg);
end{of case};
gExtended:
- case qu.Genauigkeit of
- gSingle: zi.eWerte.integriereSingle(@(qu.sWerte),xmi,xma,tmi,tma,xof,tof,rtg);
- gDouble: zi.eWerte.integriereDouble(@(qu.dWerte),xmi,xma,tmi,tma,xof,tof,rtg);
- gExtended: zi.eWerte.integriereExtended(@(qu.eWerte),xmi,xma,tmi,tma,xof,tof,rtg);
+ case qu.genauigkeit of
+ gSingle: zi.eWerte.integriereSingle(@(qu.sWerte),xMi,xMa,tMi,tMa,xOf,tOf,rtg);
+ gDouble: zi.eWerte.integriereDouble(@(qu.dWerte),xMi,xMa,tMi,tMa,xOf,tOf,rtg);
+ gExtended: zi.eWerte.integriereExtended(@(qu.eWerte),xMi,xMa,tMi,tMa,xOf,tOf,rtg);
end{of case};
end{of case};
gibAus('... und fertig',1);
@@ -6394,34 +6560,34 @@ end;
// tSortiereNachYThread ********************************************************
-constructor tSortiereNachYThread.create(K: tKontur; threads,von,bis: longint);
+constructor tSortiereNachYThread.create(k: tKontur; threads,von,bis: longint);
begin
inherited create;
- Kont:=K;
+ kont:=k;
vo:=von;
bi:=bis;
- mt:=threads;
+ mT:=threads;
erfolg:=false;
- gibAus('Sortierthread kreiert ('+inttostr(vo)+'-'+inttostr(bi)+') -> x'+inttostr(mt),1);
+ gibAus('Sortierthread kreiert ('+intToStr(vo)+'-'+intToStr(bi)+') -> x'+intToStr(mT),1);
suspended:=false;
end;
procedure tSortiereNachYThread.stExecute;
begin
- gibAus('Sortierthread gestartet ('+inttostr(vo)+'-'+inttostr(bi)+') -> x'+inttostr(mt)+' ...',1);
- erfolg:=Kont.sortiere_nach_y(mt,vo,bi);
+ gibAus('Sortierthread gestartet ('+intToStr(vo)+'-'+intToStr(bi)+') -> x'+intToStr(mT)+' ...',1);
+ erfolg:=kont.sortiereNachY(mT,vo,bi);
gibAus(' ... und fertig',1);
end;
// tBefehlThread ***************************************************************
-constructor tBefehlThread.create(st: boolean; cmd: string; out erzeugungsErfolg: boolean);
+constructor tBefehlThread.create(sT: boolean; cmd: string; out erzeugungsErfolg: boolean);
var
nichtLeeresArgument: boolean;
function shellParseNextArg(var s: string): string;
var
err: longint;
- sr: tSearchRec;
+ sR: tSearchRec;
begin
if length(s)=0 then
exit;
@@ -6436,12 +6602,12 @@ begin
else begin
result:=stringReplace(erstesArgument(s),'$$DATETIME',mydatetimetostr(now),[rfReplaceAll]);
if pos('*',result)>0 then begin
- err:=findFirst(result,$3F,sr);
+ err:=findFirst(result,$3F,sR);
while err=0 do begin
- if (sr.Name<>'.') and (sr.Name<>'..') then s:=trim('"'+extractfilepath(result)+sr.Name+'" '+s);
- err:=findNext(sr);
+ if (sR.name<>'.') and (sR.name<>'..') then s:=trim('"'+extractfilepath(result)+sR.name+'" '+s);
+ err:=findNext(sR);
end;
- findClose(sr);
+ findClose(sR);
result:=shellParseNextArg(s);
end;
end;
@@ -6451,49 +6617,49 @@ begin
nichtLeeresArgument:=true;
end;
begin
- if not st then
+ if not sT then
inherited create;
erzeugungsErfolg:=cmd<>'';
- if st then begin
+ if sT then begin
endetMit('&',cmd);
shellParseNextArg(cmd);
end
else begin
bg:=endetMit('&',cmd);
p:=tProcess.create(nil);
- p.Options:=p.Options + [poWaitOnExit];
- p.Executable:=shellParseNextArg(cmd);
+ p.options:=p.options + [poWaitOnExit];
+ p.executable:=shellParseNextArg(cmd);
end;
nichtLeeresArgument:=cmd='';
if not erzeugungsErfolg then begin
- if not st then begin
+ if not sT then begin
p.free;
p:=nil;
end;
exit;
end;
while length(cmd)>0 do begin
- if st then
+ if sT then
shellParseNextArg(cmd)
else
- p.Parameters.Add(shellParseNextArg(cmd));
+ p.parameters.add(shellParseNextArg(cmd));
if not erzeugungsErfolg then begin
- if not st then begin
+ if not sT then begin
p.free;
p:=nil;
end;
exit;
end;
end;
- if st then
+ if sT then
exit;
if not nichtLeeresArgument then begin
p.free;
p:=nil;
end;
if assigned(p) then begin
- cmd:=p.Parameters.Text;
+ cmd:=p.parameters.text;
while (length(cmd)>0) and (cmd[length(cmd)] in [#10,#13]) do
delete(cmd,length(cmd),1);
cmd:=''''+cmd+'''';
@@ -6501,7 +6667,7 @@ begin
cmd:=leftStr(cmd,pos(#10,cmd)-1)+''' '''+copy(cmd,pos(#10,cmd)+1,length(cmd));
while pos(#13,cmd)>0 do
cmd:=leftStr(cmd,pos(#13,cmd)-1)+''' '''+copy(cmd,pos(#13,cmd)+1,length(cmd));
- gibAus('Externer Befehl: '''+p.Executable+''' '+cmd+' erzeugt.',3);
+ gibAus('Externer Befehl: '''+p.executable+''' '+cmd+' erzeugt.',3);
end
else
gibAus('Des Befehls zu expandierende Argumente hatten keine Treffer, er wird ignoriert.',3);
@@ -6518,11 +6684,11 @@ procedure tBefehlThread.stExecute;
begin
if assigned(p) then begin
gibAus(
- 'externen Befehl ausführen ... '+inttostr(belegterSpeicher)+#10+
- p.Executable+#10+
- p.Parameters.text,
+ 'externen Befehl ausführen ... '+intToStr(belegterSpeicher)+#10+
+ p.executable+#10+
+ p.parameters.text,
3);
- p.Execute;
+ p.execute;
gibAus('... fertig!',1);
end
else
@@ -6537,7 +6703,7 @@ var
begin
inherited create;
w:=we;
- setlength(inputs,length(inps));
+ setLength(inputs,length(inps));
for i:=0 to length(inputs)-1 do begin
if inps[i] is tPhaseSpaceInputDateiInfo then begin
inputs[i]:=tPhaseSpaceInputDateiInfo.create(inps[i]);
@@ -6570,7 +6736,7 @@ end;
procedure tLeseThread.stExecute;
begin
gibAus('LeseThread gestartet',1);
- case w.Genauigkeit of
+ case w.genauigkeit of
gSingle:
if not w.sWerte.liesDateien(inputs) then
exit;
@@ -6586,14 +6752,14 @@ end;
// tVerzerrInitThread **********************************************************
-constructor tVerzerrInitThread.create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax,x0Abs,t0Abs,threads: longint; epsilon: extended; verzerrung: tTransformation; verzerrAnz: longint; zielpositionen: tIntPointArray; zielgewichte: tExtPointArray; Warn: tWarnstufe);
+constructor tVerzerrInitThread.create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax,x0Abs,t0Abs,threads: longint; epsilon: extended; verzerrung: tTransformation; verzerrAnz: longint; zielPositionen: tIntPointArray; zielGewichte: tExtPointArray; Warn: tWarnstufe);
begin
inherited create;
qu:=quelle;
zi:=ziel;
- ZPs:=zielpositionen;
- ZGs:=zielgewichte;
- setlength(ZAs,zi._xsteps*zi._tsiz);
+ zPs:=zielPositionen;
+ zGs:=zielGewichte;
+ setLength(zAs,zi._xSteps*zi._tSiz);
xMi:=xMin;
xMa:=xMax;
tMi:=tMin;
@@ -6602,8 +6768,8 @@ begin
t0:=t0Abs;
eps:=epsilon;
verz:=verzerrung;
- va:=verzerrAnz;
- mt:=threads;
+ vA:=verzerrAnz;
+ mT:=threads;
Warnstufe:=Warn;
gibAus('VerzerrInitThread kreiert',1);
suspended:=false;
@@ -6611,69 +6777,69 @@ end;
destructor tVerzerrInitThread.destroy;
begin
- setlength(ZAs,0);
+ setLength(zAs,0);
inherited destroy;
end;
procedure tVerzerrInitThread.stExecute;
begin
- gibAus('VerzerrInitThread gestartet ('+inttostr(xMi)+'-'+inttostr(xMa)+'/'+inttostr(tMi)+'-'+inttostr(tMa)+')',1);
- zi.initVerzerrung(qu,xMi,xMa,tMi,tMa,x0,t0,mt,false,eps,verz,va,ZPs,ZGs,ZAs,Warnstufe);
+ gibAus('VerzerrInitThread gestartet ('+intToStr(xMi)+'-'+intToStr(xMa)+'/'+intToStr(tMi)+'-'+intToStr(tMa)+')',1);
+ zi.initVerzerrung(qu,xMi,xMa,tMi,tMa,x0,t0,mT,false,eps,verz,vA,zPs,zGs,zAs,Warnstufe);
gibAus('VerzerrInitThread beendet',1);
end;
// tVerzerrThread **************************************************************
-constructor tVerzerrThread.create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax: longint; zielpositionen: tIntPointArray; zielgewichte: tExtPointArray; zielanzahlen: tExtendedArray; Vorbearbeitungen,Nachbearbeitungen: tTransformation; vorAnz,nachAnz: longint);
+constructor tVerzerrThread.create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax: longint; zielPositionen: tIntPointArray; zielGewichte: tExtPointArray; zielAnzahlen: tExtendedArray; vorbearbeitungen,nachbearbeitungen: tTransformation; vorAnz,nachAnz: longint);
begin
inherited create;
qu:=quelle;
zi:=ziel;
- ZPs:=zielpositionen;
- ZGs:=zielgewichte;
- ZAs:=zielanzahlen;
+ zPs:=zielPositionen;
+ zGs:=zielGewichte;
+ zAs:=zielAnzahlen;
xMi:=xMin;
xMa:=xMax;
tMi:=tMin;
tMa:=tMax;
- vb:=Vorbearbeitungen;
- va:=vorAnz;
- nb:=Nachbearbeitungen;
- na:=nachAnz;
+ vB:=vorbearbeitungen;
+ vA:=vorAnz;
+ nB:=nachbearbeitungen;
+ nA:=nachAnz;
gibAus('Verzerrthread erzeugt',1);
suspended:=false;
end;
procedure tVerzerrThread.stExecute;
begin
- gibAus('Verzerrthread gestartet '+floattostr(qu._minW)+' '+floattostr(qu._maxW),1);
+ gibAus('Verzerrthread gestartet '+floatToStr(qu._minW)+' '+floatToStr(qu._maxW),1);
case zi.genauigkeit of
gSingle:
case qu.genauigkeit of
gSingle:
- zi.sWerte.kopiereVerzerrt(pTLLWerteSingle(@qu.sWerte),ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb,va,na);
+ zi.sWerte.kopiereVerzerrt(pTLLWerteSingle(@qu.sWerte),zPs,zGs,zAs,xMi,xMa,tMi,tMa,vB,nB,vA,nA);
gDouble:
- zi.sWerte.kopiereVerzerrt(pTLLWerteDouble(@qu.dWerte),ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb,va,na);
+ zi.sWerte.kopiereVerzerrt(pTLLWerteDouble(@qu.dWerte),zPs,zGs,zAs,xMi,xMa,tMi,tMa,vB,nB,vA,nA);
gExtended:
- zi.sWerte.kopiereVerzerrt(pTLLWerteExtended(@qu.eWerte),ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb,va,na);
+ zi.sWerte.kopiereVerzerrt(pTLLWerteExtended(@qu.eWerte),zPs,zGs,zAs,xMi,xMa,tMi,tMa,vB,nB,vA,nA);
end{of case};
gDouble:
case qu.genauigkeit of
gSingle:
- zi.dWerte.kopiereVerzerrt(pTLLWerteSingle(@qu.sWerte),ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb,va,na);
+ zi.dWerte.kopiereVerzerrt(pTLLWerteSingle(@qu.sWerte),zPs,zGs,zAs,xMi,xMa,tMi,tMa,vB,nB,vA,nA);
gDouble:
- zi.dWerte.kopiereVerzerrt(pTLLWerteDouble(@qu.dWerte),ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb,va,na);
+ zi.dWerte.kopiereVerzerrt(pTLLWerteDouble(@qu.dWerte),zPs,zGs,zAs,xMi,xMa,tMi,tMa,vB,nB,vA,nA);
gExtended:
- zi.dWerte.kopiereVerzerrt(pTLLWerteExtended(@qu.eWerte),ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb,va,na);
+ zi.dWerte.kopiereVerzerrt(pTLLWerteExtended(@qu.eWerte),zPs,zGs,zAs,xMi,xMa,tMi,tMa,vB,nB,vA,nA);
end{of case};
gExtended:
case qu.genauigkeit of
gSingle:
- zi.eWerte.kopiereVerzerrt(pTLLWerteSingle(@qu.sWerte),ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb,va,na);
+ zi.eWerte.kopiereVerzerrt(pTLLWerteSingle(@qu.sWerte),zPs,zGs,zAs,xMi,xMa,tMi,tMa,vB,nB,vA,nA);
gDouble:
- zi.eWerte.kopiereVerzerrt(pTLLWerteDouble(@qu.dWerte),ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb,va,na);
+ zi.eWerte.kopiereVerzerrt(pTLLWerteDouble(@qu.dWerte),zPs,zGs,zAs,xMi,xMa,tMi,tMa,vB,nB,vA,nA);
gExtended:
- zi.eWerte.kopiereVerzerrt(pTLLWerteExtended(@qu.eWerte),ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb,va,na);
+ zi.eWerte.kopiereVerzerrt(pTLLWerteExtended(@qu.eWerte),zPs,zGs,zAs,xMi,xMa,tMi,tMa,vB,nB,vA,nA);
end{of case};
end{of case};
gibAus('Verzerrthread beendet',1);
@@ -6692,13 +6858,13 @@ begin
tMa:=tMax;
verhHo:=verhaeltnisHorizontal;
verhVe:=verhaeltnisVertikal;
- gibAus('VerzerrLOthread erzeugt: '+inttostr(xmin)+'-'+inttostr(xmax)+' '+inttostr(tmin)+'-'+inttostr(tmax),1);
+ gibAus('VerzerrLOthread erzeugt: '+intToStr(xMin)+'-'+intToStr(xMax)+' '+intToStr(tMin)+'-'+intToStr(tMax),1);
suspended:=false;
end;
procedure tVerzerrLOThread.stExecute;
begin
- gibAus('VerzerrLOthread gestartet '+floattostr(qu._minW)+' '+floattostr(qu._maxW),1);
+ gibAus('VerzerrLOthread gestartet '+floatToStr(qu._minW)+' '+floatToStr(qu._maxW),1);
case zi.genauigkeit of
gSingle:
case qu.genauigkeit of
@@ -6733,7 +6899,7 @@ end;
// tFensterThread **************************************************************
-constructor tFensterThread.create(werte: tWerte; xMin,xMax,tMin,tMax: longint; x_Fenster,t_Fenster: tFenster; hintergrund: extended);
+constructor tFensterThread.create(werte: tWerte; xMin,xMax,tMin,tMax: longint; fensterX,fensterT: tFenster; hintergrund: extended);
begin
inherited create;
we:=werte;
@@ -6741,14 +6907,14 @@ begin
xMa:=xMax;
tMi:=tMin;
tMa:=tMax;
- xFen:=x_Fenster;
- tFen:=t_Fenster;
+ xFen:=fensterX;
+ tFen:=fensterT;
hg:=hintergrund;
- if length(xFen.werte)<>werte._xsteps then
- xFen.berechneWerte(werte._xsteps);
- if length(tFen.werte)<>werte._tsiz then
- tFen.berechneWerte(werte._tsiz);
- gibAus('FensterThread erzeugt: '+inttostr(xmin)+'-'+inttostr(xmax)+' '+inttostr(tmin)+'-'+inttostr(tmax),1);
+ if length(xFen.werte)<>werte._xSteps then
+ xFen.berechneWerte(werte._xSteps);
+ if length(tFen.werte)<>werte._tSiz then
+ tFen.berechneWerte(werte._tSiz);
+ gibAus('FensterThread erzeugt: '+intToStr(xMin)+'-'+intToStr(xMax)+' '+intToStr(tMin)+'-'+intToStr(tMax),1);
suspended:=false;
end;
@@ -6768,7 +6934,7 @@ end;
// sonstiges *******************************************************************
-function findePalette(out Palette: pTPalette; name: string): boolean;
+function findePalette(out palette: pTPalette; name: string): boolean;
var
i: longint;
begin
@@ -6776,25 +6942,25 @@ begin
for i:=0 to length(paletten)-1 do
if paletten[i].name=name then
begin
- Palette:=@(paletten[i]);
+ palette:=@(paletten[i]);
exit;
end;
- Palette:=nil;
+ palette:=nil;
result:=false;
end;
-function erzeugeLegende(st: boolean; 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,
+ breite,hoehe,i,j,k,lO,rO,oO,uO,
schriftgroesze: longint;
img: file;
lineareFarbe,waagerecht,rahmen: boolean;
- farben: tRgbArray;
+ farben: tRGBArray;
col: tRGB;
wert,tmp,schritt: extended;
fontRenderer: tFontRenderer;
- beschriftungsschritte: array of tBeschriftungsschritt;
+ beschriftungsschritte: array of tBeschriftungsSchritt;
beschriftungen: array of tBeschriftung;
tmpTr: tTransformation;
bekannteBefehle: tMyStringList;
@@ -6805,8 +6971,8 @@ begin
waagerecht:=false;
lineareFarbe:=false;
schriftgroesze:=24;
- setlength(beschriftungen,0);
- setlength(beschriftungsschritte,2);
+ setLength(beschriftungen,0);
+ setLength(beschriftungsschritte,2);
beschriftungsschritte[0].schritte:=0;
beschriftungsschritte[0].bis:=minDichte;
beschriftungsschritte[0].linear:=false;
@@ -6855,7 +7021,7 @@ begin
continue;
end;
if istDasBefehl('Beschriftungen:',s,bekannteBefehle,false) then begin
- setlength(beschriftungsschritte,1);
+ setLength(beschriftungsschritte,1);
beschriftungsschritte[0].schritte:=0;
beschriftungsschritte[0].bis:=minDichte;
beschriftungsschritte[0].linear:=false;
@@ -6868,18 +7034,18 @@ begin
end;
if s='Ende' then
break;
- setlength(beschriftungsschritte,length(beschriftungsschritte)+1);
+ setLength(beschriftungsschritte,length(beschriftungsschritte)+1);
if startetMit('linear',s) then
beschriftungsschritte[length(beschriftungsschritte)-1].linear:=true
else if startetMit('logarithmisch',s) then begin
beschriftungsschritte[length(beschriftungsschritte)-1].linear:=false;
- minDichte:=Qu.exprtofloat(st,erstesArgument(s));
+ minDichte:=qu.exprToFloat(sT,erstesArgument(s));
beschriftungsschritte[0].bis:=maxDichte*minDichte;
- tmpTr:=nb;
+ tmpTr:=nB;
while assigned(tmpTr) do begin
if tmpTr is tWerteLogTransformation then begin
if (tmpTr as tWerteLogTransformation).logMin<>minDichte then begin
- gibAus('Die minimale Dichte der logarithmischen Farbskala ('+myfloattostr(minDichte)+') und der logarithmischen Nachbearbeitung ('+myfloattostr((tmpTr as tWerteLogTransformation).logMin)+') stimmen nicht überein!',3);
+ gibAus('Die minimale Dichte der logarithmischen Farbskala ('+myFloatToStr(minDichte)+') und der logarithmischen Nachbearbeitung ('+myFloatToStr((tmpTr as tWerteLogTransformation).logMin)+') stimmen nicht überein!',3);
exit;
end;
minDichte:=minDichte*maxDichte;
@@ -6896,7 +7062,7 @@ begin
bekannteBefehle.free;
exit;
end;
- beschriftungsschritte[length(beschriftungsschritte)-1].bis:=Qu.exprtofloat(st,erstesArgument(s));
+ beschriftungsschritte[length(beschriftungsschritte)-1].bis:=qu.exprToFloat(sT,erstesArgument(s));
if endetMit('+',s) then beschriftungsschritte[length(beschriftungsschritte)-1].faktor:=0.5
else if endetMit('-',s) then beschriftungsschritte[length(beschriftungsschritte)-1].faktor:=2
else beschriftungsschritte[length(beschriftungsschritte)-1].faktor:=1;
@@ -6913,22 +7079,22 @@ begin
until false;
bekannteBefehle.free;
- if st then begin
+ if sT then begin
result:=true;
exit;
end;
fontRenderer:=tFontRenderer.create(schriftgroesze);
- gibAus(floattostr(minDichte)+' '+floattostr(maxDichte),1);
+ gibAus(floatToStr(minDichte)+' '+floatToStr(maxDichte),1);
for i:=0 to length(beschriftungsschritte)-1 do
- gibAus(inttostr(i)+' '+floattostr(beschriftungsschritte[i].bis)+' '+floattostr(beschriftungsschritte[i].faktor)+' '+inttostr(beschriftungsschritte[i].schritte)+' '+inttostr(byte(beschriftungsschritte[i].linear)),1);
+ gibAus(intToStr(i)+' '+floatToStr(beschriftungsschritte[i].bis)+' '+floatToStr(beschriftungsschritte[i].faktor)+' '+intToStr(beschriftungsschritte[i].schritte)+' '+intToStr(byte(beschriftungsschritte[i].linear)),1);
i:=0;
wert:=minDichte;
schritt:=-1;
while wert<maxDichte do begin
- if i>0 then gibAus(inttostr(i)+' '+floattostr(wert)+' '+floattostr(schritt)+' '+floattostr(beschriftungsschritte[i].bis),1);
+ if i>0 then gibAus(intToStr(i)+' '+floatToStr(wert)+' '+floatToStr(schritt)+' '+floatToStr(beschriftungsschritte[i].bis),1);
if ((i<length(beschriftungsschritte)-1) and (wert>beschriftungsschritte[i].bis)) or (i=0) then begin
repeat
inc(i);
@@ -6942,16 +7108,16 @@ begin
tmp:=round(beschriftungsschritte[i-1].bis/schritt)*schritt;
while tmp<wert do tmp:=(round(tmp/schritt)+1)*schritt;
wert:=tmp;
- gibAus(inttostr(i)+' '+floattostr(wert)+' '+floattostr(schritt)+' '+floattostr(beschriftungsschritte[i].bis),1);
+ gibAus(intToStr(i)+' '+floatToStr(wert)+' '+floatToStr(schritt)+' '+floatToStr(beschriftungsschritte[i].bis),1);
end;
- setlength(beschriftungen,length(beschriftungen)+1);
+ setLength(beschriftungen,length(beschriftungen)+1);
beschriftungen[length(beschriftungen)-1]:=tBeschriftung.create;
beschriftungen[length(beschriftungen)-1].bBreite:=breite;
beschriftungen[length(beschriftungen)-1].bHoehe:=hoehe;
- beschriftungen[length(beschriftungen)-1].Rahmen:=Rahmen;
+ beschriftungen[length(beschriftungen)-1].rahmen:=rahmen;
beschriftungen[length(beschriftungen)-1].fontRend:=fontRenderer;
beschriftungen[length(beschriftungen)-1].position:=(wert-minDichte)/(maxDichte-minDichte);
- beschriftungen[length(beschriftungen)-1].inhalt:=floattostr(wert);
+ beschriftungen[length(beschriftungen)-1].inhalt:=floatToStr(wert);
if not beschriftungsschritte[i].linear then
schritt:=power(10,floor(ln(wert)/ln(10)-beschriftungsschritte[i].schritte))*beschriftungsschritte[i].faktor;
wert:=(round(wert/schritt)+1)*schritt;
@@ -6959,36 +7125,36 @@ begin
if lineareFarbe then
for i:=0 to length(beschriftungen)-1 do
- beschriftungen[i].position:=nb.transformiereWert(beschriftungen[i].position);
+ beschriftungen[i].position:=nB.transformiereWert(beschriftungen[i].position);
for i:=0 to length(beschriftungen)-1 do
beschriftungen[i].position:=beschriftungen[i].position*(hoehe+byte(waagerecht)*(breite-hoehe));
- lo:=Byte(Rahmen);
- ro:=Byte(Rahmen);
- oo:=Byte(Rahmen);
- uo:=Byte(Rahmen);
+ lO:=byte(rahmen);
+ rO:=byte(rahmen);
+ oO:=byte(rahmen);
+ uO:=byte(rahmen);
for i:=0 to length(beschriftungen)-1 do begin
- lo:=max(lo,-beschriftungen[i].links);
- ro:=max(ro,1+beschriftungen[i].rechts-breite);
- oo:=max(oo,-beschriftungen[i].oben);
- uo:=max(uo,1+beschriftungen[i].unten-hoehe);
+ lO:=max(lO,-beschriftungen[i].links);
+ rO:=max(rO,1+beschriftungen[i].rechts-breite);
+ oO:=max(oO,-beschriftungen[i].oben);
+ uO:=max(uO,1+beschriftungen[i].unten-hoehe);
end;
- if lo+oo+ro+uo>0 then
- gibAus('Extra-Ränder: '+inttostr(lo)+' Pixel links, '+inttostr(oo)+' Pixel oben, '+inttostr(ro)+' Pixel rechts und '+inttostr(uo)+' Pixel unten.',3);
+ if lO+oO+rO+uO>0 then
+ gibAus('Extra-Ränder: '+intToStr(lO)+' Pixel links, '+intToStr(oO)+' Pixel oben, '+intToStr(rO)+' Pixel rechts und '+intToStr(uO)+' Pixel unten.',3);
- setlength(farben,byte(waagerecht)*(breite-hoehe)+hoehe);
+ setLength(farben,byte(waagerecht)*(breite-hoehe)+hoehe);
for i:=0 to length(farben)-1 do begin
wert:=i/length(farben);
if not lineareFarbe then
- wert:=nb.transformiereWert(wert);
+ wert:=nB.transformiereWert(wert);
farben[i]:=wertZuFarbe(wert,pal^.farben);
end;
assign(img,datei);
rewrite(img,1);
- schreibeBmpHeader(img,breite+lo+ro,hoehe+oo+uo);
- for j:=-oo to hoehe+uo-1 do begin
- i:=-lo;
- while i<breite+ro do
+ schreibeBmpHeader(img,breite+lO+rO,hoehe+oO+uO);
+ for j:=-oO to hoehe+uO-1 do begin
+ i:=-lO;
+ while i<breite+rO do
if waagerecht and (i=0) and (j>=0) and (j<hoehe) then begin
blockwrite(img,farben[0],3*breite);
i:=breite;
@@ -7009,14 +7175,14 @@ begin
col.rgbBlue:=$00;
end;
end;
- for k:=0 to length(Beschriftungen)-1 do
- with Beschriftungen[k] do begin
+ for k:=0 to length(beschriftungen)-1 do
+ with beschriftungen[k] do begin
if (links<=i) and (rechts>=i) and (oben<=j) and (unten>=j) then
col:=andFarben(col,bild.farben[i-links + (j-oben)*bild.breite]);
- if ((bBreite<=i) and (i<bBreite+4+byte(Rahmen)) and (lage = lRechts) and (strich=j)) or
- ((-4<=i+byte(Rahmen)) and (i<0) and (lage = lLinks) and (strich=j)) or
- ((bHoehe<=j) and (j<bHoehe+4+byte(Rahmen)) and (lage = lOben) and (strich=i)) or
- ((-4<=j+byte(Rahmen)) and (j<0) and (lage = lUnten) and (strich=i)) then begin
+ if ((bBreite<=i) and (i<bBreite+4+byte(rahmen)) and (lage = lRechts) and (strich=j)) or
+ ((-4<=i+byte(rahmen)) and (i<0) and (lage = lLinks) and (strich=j)) or
+ ((bHoehe<=j) and (j<bHoehe+4+byte(rahmen)) and (lage = lOben) and (strich=i)) or
+ ((-4<=j+byte(rahmen)) and (j<0) and (lage = lUnten) and (strich=i)) then begin
col.rgbRed:=$00;
col.rgbGreen:=$00;
col.rgbBlue:=$00;
@@ -7027,51 +7193,19 @@ begin
inc(i);
end;
i:=0;
- blockwrite(img,i,(4-(((breite+lo+ro)*3) mod 4)) mod 4);
+ blockwrite(img,i,(4-(((breite+lO+rO)*3) mod 4)) mod 4);
end;
for i:=0 to length(beschriftungen)-1 do
beschriftungen[i].free;
- setlength(beschriftungen,0);
+ setLength(beschriftungen,0);
close(img);
fontRenderer.free;
result:=true;
end;
-function strToFftDo(out fftDo: tFFTDatenordnung; s: string): boolean;
-var
- bekannteBefehle: tMyStringList;
-begin
- result:=true;
- bekannteBefehle:=tMyStringList.create;
- if istDasBefehl('Realteile:Imaginärteile',s,bekannteBefehle,false) then begin
- fftDo:=doResIms;
- bekannteBefehle.free;
- exit;
- end;
- if istDasBefehl('Realteile:Imaginärteile umgedreht',s,bekannteBefehle,false) then begin
- fftDo:=doResSmi;
- bekannteBefehle.free;
- exit;
- end;
- if istDasBefehl('Beträge',s,bekannteBefehle,false) then begin
- fftDo:=doBetr;
- bekannteBefehle.free;
- exit;
- end;
- if istDasBefehl('Betragsquadrate',s,bekannteBefehle,false) then begin
- fftDo:=doBetrQdr;
- bekannteBefehle.free;
- exit;
- end;
- bekannteBefehle.sort;
- gibAus('Kenne Nachbereitungsvariante '''+s+''' nicht bei Erstellung einer FFT!'#10'Ich kenne:'#10+bekannteBefehle.text,3);
- bekannteBefehle.free;
- result:=false;
-end;
-
-function findeWerte(s: String; f: tMyStringlist; pws: pTWerteArray; Kont: pTKonturenArray; darfErstellen: boolean): integer;
+function findeWerte(s: string; f: tMyStringList; pws: pTWerteArray; kont: pTKonturenArray; darfErstellen: boolean): integer;
var
i: integer;
istZahl: boolean;
@@ -7081,7 +7215,7 @@ begin
while (result<length(pws^)) and (pws^[result].bezeichner<>s) do
inc(result);
if result<length(pws^) then begin // Werte gefunden!
- pws^[result].warteaufBeendigungDesLeseThreads;
+ pws^[result].warteAufBeendigungDesLeseThreads;
exit;
end;
@@ -7092,11 +7226,11 @@ begin
if istZahl then begin // bei s handelt es sich um den Index selbst
result:=strtoint(s);
if (result<0) or (result>=length(pws^)) then begin
- gibAus('Index ('+s+') liegt außerhalb des gültigen Bereichs (0..'+inttostr(length(pws^)-1)+')!',3);
+ gibAus('Index ('+s+') liegt außerhalb des gültigen Bereichs (0..'+intToStr(length(pws^)-1)+')!',3);
result:=-1;
end
else
- pws^[result].warteaufBeendigungDesLeseThreads;
+ pws^[result].warteAufBeendigungDesLeseThreads;
exit;
end;
@@ -7106,8 +7240,8 @@ begin
exit;
end;
- setlength(pws^,length(pws^)+1);
- pws^[length(pws^)-1]:=tWerte.create(Kont,pws);
+ setLength(pws^,length(pws^)+1);
+ pws^[length(pws^)-1]:=tWerte.create(kont,pws);
pws^[length(pws^)-1].bezeichner:=s;
i:=f.count-1;
@@ -7122,7 +7256,7 @@ begin
result:=length(pws^)-1;
end;
-function findeKontur(s: String; f: tMyStringlist; pws: pTWerteArray; pks: pTKonturenArray; darfErstellen: boolean): integer;
+function findeKontur(s: string; f: tMyStringList; pws: pTWerteArray; pks: pTKonturenArray; darfErstellen: boolean): integer;
var
i: integer;
istZahl: boolean;
@@ -7140,19 +7274,19 @@ begin
if istZahl then begin // bei s handelt es sich um den Index selbst
result:=strtoint(s);
if (result<0) or (result>=length(pks^)) then begin
- gibAus('Index ('+s+') liegt außerhalb des gültigen Bereichs (0..'+inttostr(length(pks^)-1)+')!',3);
+ gibAus('Index ('+s+') liegt außerhalb des gültigen Bereichs (0..'+intToStr(length(pks^)-1)+')!',3);
result:=-1;
end;
exit;
end;
if not darfErstellen then begin
- gibAus('Ich habe Konturen '''+s+''' nicht gefunden und darf sie auch nicht erstellen!',3);
+ gibAus('Ich habe Kontur '''+s+''' nicht gefunden und darf sie auch nicht erstellen!',3);
result:=-1;
exit;
end;
- setlength(pks^,length(pks^)+1);
+ setLength(pks^,length(pks^)+1);
pks^[length(pks^)-1]:=tKontur.create(pks,pws);
pks^[length(pks^)-1].bezeichner:=s;
@@ -7170,7 +7304,7 @@ end;
function initBmpHeader(w,h: longint): tBmpHeader;
begin
- With result do begin
+ with result do begin
bfType1 := $42;
bfType2 := $4D;
bfSize := $36 + ((3*w+3) div 4)*4*h;
@@ -7196,18 +7330,18 @@ var
bmpHeader: tBmpHeader;
begin
bmpHeader:=initBmpHeader(w,h);
- blockwrite(f,bmpHeader,sizeof(bmpHeader));
+ blockwrite(f,bmpHeader,sizeOf(bmpHeader));
end;
-function neuePalette(f: tMyStringlist): boolean;
+function neuePalette(f: tMyStringList): boolean;
var
s,name: string;
- Palette: tRGBArray;
+ palette: tRGBArray;
i: longint;
nPalette: pTPalette;
begin
result:=false;
- setlength(Palette,0);
+ setLength(palette,0);
name:='';
nPalette:=nil;
repeat
@@ -7221,8 +7355,8 @@ begin
findePalette(nPalette,s);
continue;
end;
- setlength(Palette,length(Palette)+1);
- if strToTRGB(s,Palette[length(Palette)-1]) then continue;
+ setLength(palette,length(palette)+1);
+ if strToTRGB(s,palette[length(palette)-1]) then continue;
gibAus(''''+s+''' ist keine Farbe für eine Palette!',3);
exit;
until false;
@@ -7230,28 +7364,28 @@ begin
gibAus('Die Palette braucht einen Namen!',3);
exit;
end;
- if length(Palette)<2 then begin
- gibAus('Zu wenige Farben in der Palette '''+name+''', nämlich nur '+inttostr(length(Palette)),3);
+ if length(palette)<2 then begin
+ gibAus('Zu wenige Farben in der Palette '''+name+''', nämlich nur '+intToStr(length(palette)),3);
exit;
end;
if nPalette=nil then begin
- setlength(Paletten,length(Paletten)+1);
- nPalette:=@(Paletten[length(Paletten)-1]);
+ setLength(paletten,length(paletten)+1);
+ nPalette:=@(paletten[length(paletten)-1]);
end;
nPalette^.name:=name;
- setlength(nPalette^.farben,length(Palette));
- for i:=0 to length(Palette)-1 do
- nPalette^.farben[i]:=Palette[i];
+ setLength(nPalette^.farben,length(palette));
+ for i:=0 to length(palette)-1 do
+ nPalette^.farben[i]:=palette[i];
gibAus('Neue Palette '''+nPalette^.name+''' erstellt!',3);
result:=true;
end;
-function externerBefehl(st: boolean; s: string): boolean;
+function externerBefehl(sT: boolean; s: string): boolean;
var
bt: tBefehlThread;
begin
- bt:=tBefehlThread.create(st,s,result);
- if st then begin
+ bt:=tBefehlThread.create(sT,s,result);
+ if sT then begin
// bt.free;
exit;
end;
@@ -7265,7 +7399,7 @@ begin
bt.suspended:=false;
gibAus('Befehl gestartet.',3);
if bt.bg then begin
- setlength(externeBefehle,length(externeBefehle)+1);
+ setLength(externeBefehle,length(externeBefehle)+1);
externeBefehle[length(externeBefehle)-1]:=bt;
exit; // Job läuft im Hintergrund weiter!
end;
@@ -7274,7 +7408,7 @@ begin
bt.free;
end;
-procedure warte_auf_externeBefehle;
+procedure warteAufExterneBefehle;
var
i: longint;
b,c: boolean;
@@ -7294,7 +7428,7 @@ begin
gibAus('... alle externen Befehle fertig.',3);
for i:=0 to length(externeBefehle)-1 do
if assigned(externeBefehle[i]) then externeBefehle[i].free;
- setlength(externeBefehle,0);
+ setLength(externeBefehle,0);
end;
procedure beendeExterneBefehleWennFertig;
@@ -7307,61 +7441,61 @@ begin
externeBefehle[i].free;
for j:=i+1 to length(externeBefehle)-1 do
externeBefehle[j-1]:=externeBefehle[j];
- setlength(externeBefehle,length(externeBefehle)-1);
+ setLength(externeBefehle,length(externeBefehle)-1);
end;
end;
begin
fileMode := fmOpenRead;
- setlength(externeBefehle,0);
-
- setlength(Paletten,6);
- Paletten[0].name:='Graustufen';
- setlength(Paletten[0].farben,2);
- Paletten[0].farben[0]:=rgb($ff,$ff,$ff);
- Paletten[0].farben[1]:=rgb($00,$00,$00);
-
- Paletten[1].name:='invertierte Graustufen';
- setlength(Paletten[1].farben,2);
- Paletten[1].farben[0]:=rgb($00,$00,$00);
- Paletten[1].farben[1]:=rgb($ff,$ff,$ff);
-
- Paletten[2].name:='Regenbogen';
- setlength(Paletten[2].farben,6);
- Paletten[2].farben[0]:=rgb($00,$00,$ff);
- Paletten[2].farben[1]:=rgb($00,$ff,$ff);
- Paletten[2].farben[2]:=rgb($00,$ff,$00);
- Paletten[2].farben[3]:=rgb($ff,$ff,$00);
- Paletten[2].farben[4]:=rgb($ff,$00,$00);
- Paletten[2].farben[5]:=rgb($00,$00,$00);
-
- Paletten[3].name:='invertierter Regenbogen';
- setlength(Paletten[3].farben,6);
- Paletten[3].farben[0]:=rgb($00,$00,$00);
- Paletten[3].farben[1]:=rgb($ff,$00,$00);
- Paletten[3].farben[2]:=rgb($ff,$ff,$00);
- Paletten[3].farben[3]:=rgb($00,$ff,$00);
- Paletten[3].farben[4]:=rgb($00,$ff,$ff);
- Paletten[3].farben[5]:=rgb($00,$00,$ff);
-
- Paletten[4].name:='Jet-Regenbogen';
- setlength(Paletten[4].farben,5);
- Paletten[4].farben[0]:=rgb($ff,$00,$00);
- Paletten[4].farben[1]:=rgb($ff,$ff,$00);
- Paletten[4].farben[2]:=rgb($00,$ff,$00);
- Paletten[4].farben[3]:=rgb($00,$ff,$ff);
- Paletten[4].farben[4]:=rgb($00,$00,$ff);
-
- Paletten[5].name:='erweiterter Regenbogen';
- setlength(Paletten[5].farben,8);
- Paletten[5].farben[0]:=rgb($ff,$ff,$ff);
- Paletten[5].farben[1]:=rgb($00,$00,$ff);
- Paletten[5].farben[2]:=rgb($00,$ff,$ff);
- Paletten[5].farben[3]:=rgb($00,$ff,$00);
- Paletten[5].farben[4]:=rgb($ff,$ff,$00);
- Paletten[5].farben[5]:=rgb($ff,$00,$00);
- Paletten[5].farben[6]:=rgb($ff,$00,$ff);
- Paletten[5].farben[7]:=rgb($00,$00,$00);
+ setLength(externeBefehle,0);
+
+ setLength(paletten,6);
+ paletten[0].name:='Graustufen';
+ setLength(paletten[0].farben,2);
+ paletten[0].farben[0]:=rgb($ff,$ff,$ff);
+ paletten[0].farben[1]:=rgb($00,$00,$00);
+
+ paletten[1].name:='invertierte Graustufen';
+ setLength(paletten[1].farben,2);
+ paletten[1].farben[0]:=rgb($00,$00,$00);
+ paletten[1].farben[1]:=rgb($ff,$ff,$ff);
+
+ paletten[2].name:='Regenbogen';
+ setLength(paletten[2].farben,6);
+ paletten[2].farben[0]:=rgb($00,$00,$ff);
+ paletten[2].farben[1]:=rgb($00,$ff,$ff);
+ paletten[2].farben[2]:=rgb($00,$ff,$00);
+ paletten[2].farben[3]:=rgb($ff,$ff,$00);
+ paletten[2].farben[4]:=rgb($ff,$00,$00);
+ paletten[2].farben[5]:=rgb($00,$00,$00);
+
+ paletten[3].name:='invertierter Regenbogen';
+ setLength(paletten[3].farben,6);
+ paletten[3].farben[0]:=rgb($00,$00,$00);
+ paletten[3].farben[1]:=rgb($ff,$00,$00);
+ paletten[3].farben[2]:=rgb($ff,$ff,$00);
+ paletten[3].farben[3]:=rgb($00,$ff,$00);
+ paletten[3].farben[4]:=rgb($00,$ff,$ff);
+ paletten[3].farben[5]:=rgb($00,$00,$ff);
+
+ paletten[4].name:='Jet-Regenbogen';
+ setLength(paletten[4].farben,5);
+ paletten[4].farben[0]:=rgb($ff,$00,$00);
+ paletten[4].farben[1]:=rgb($ff,$ff,$00);
+ paletten[4].farben[2]:=rgb($00,$ff,$00);
+ paletten[4].farben[3]:=rgb($00,$ff,$ff);
+ paletten[4].farben[4]:=rgb($00,$00,$ff);
+
+ paletten[5].name:='erweiterter Regenbogen';
+ setLength(paletten[5].farben,8);
+ paletten[5].farben[0]:=rgb($ff,$ff,$ff);
+ paletten[5].farben[1]:=rgb($00,$00,$ff);
+ paletten[5].farben[2]:=rgb($00,$ff,$ff);
+ paletten[5].farben[3]:=rgb($00,$ff,$00);
+ paletten[5].farben[4]:=rgb($ff,$ff,$00);
+ paletten[5].farben[5]:=rgb($ff,$00,$00);
+ paletten[5].farben[6]:=rgb($ff,$00,$ff);
+ paletten[5].farben[7]:=rgb($00,$00,$00);
end.
diff --git a/typenunit.pas b/typenunit.pas
index 5cb1621..a5fe65b 100644
--- a/typenunit.pas
+++ b/typenunit.pas
@@ -5,30 +5,30 @@ unit typenunit;
interface
uses
- sysutils, agg_2D, FPimage, agg_basics, classes, Math, mystringlistunit, lowlevelunit, matheunit;
+ sysutils, agg_2D, FPimage, agg_basics, classes, math, mystringlistunit, lowlevelunit, matheunit;
-const Speicherhappen = 32768; // Anzahl an mit einem Mal zu reservierender Arrayzellen
+const speicherHappen = 32768; // Anzahl an mit einem Mal zu reservierender Arrayzellen
myInf = 1e12;
- FeldgroeszenNamen: array[0..9] of string = ('FP','FM','GP','GM','EX','DENS_E','DENS_I','JX','JY','JZ');
+ feldGroeszenNamen: array[0..9] of string = ('FP','FM','GP','GM','EX','DENS_E','DENS_I','JX','JY','JZ');
// verbosity: longint = 0;
type
tExtraInfos = class;
tIntegrationsRichtung = (irHorizontal,irEinfall,irAusfall);
tGenerischeInputDateiInfo = class // nur zum Vererben gedacht, nie selbst instanziieren!
- Name,Fehlerbehebungskommando: string;
+ name,fehlerBehebungsKommando: string;
gamma,groeszenFaktor,
- tstart,tstop,xstart,xstop: extended;
- Genauigkeit: tGenauigkeit;
- xsteps,tsiz,t0abs: longint;
- params: tExtrainfos;
+ tStart,tStop,xStart,xStop: extended;
+ genauigkeit: tGenauigkeit;
+ xSteps,tSiz,t0Abs: longint;
+ params: tExtraInfos;
constructor create(Vorlage: tGenerischeInputDateiInfo); overload;
constructor create; overload;
destructor destroy; override;
- function xmin: longint;
- function xmax: longint;
- function tmin: longint;
- function tmax: longint;
+ function xMin: longint;
+ function xMax: longint;
+ function tMin: longint;
+ function tMax: longint;
end;
tPhaseSpaceInputDateiInfo = class (tGenerischeInputDateiInfo)
constructor create(Vorlage: tGenerischeInputDateiInfo); overload;
@@ -41,28 +41,28 @@ type
destructor destroy; override;
end;
tTraceInputDateiInfo = class (tGenerischeInputDateiInfo)
- SpurNummer,FeldNummer: longint;
+ spurNummer,feldNummer: longint;
constructor create(Vorlage: tGenerischeInputDateiInfo); overload;
constructor create; overload;
destructor destroy; override;
end;
tSergeyInputDateiInfo = class (tGenerischeInputDateiInfo)
- FeldNummer: longint;
+ feldNummer: longint;
constructor create(Vorlage: tGenerischeInputDateiInfo); overload;
constructor create; overload;
destructor destroy; override;
end;
tPipeInputDateiInfo = class (tGenerischeInputDateiInfo)
- Analysator: string;
+ analysator: string;
bytesPerSample: longint;
Kodierung: tKodierung;
constructor create(Vorlage: tGenerischeInputDateiInfo); overload;
constructor create; overload;
destructor destroy; override;
- function Executable: string;
- function ParametersText: string;
- function AnalysatorExecutable: string;
- function AnalysatorParametersText: string;
+ function executable: string;
+ function parametersText: string;
+ function analysatorExecutable: string;
+ function analysatorParametersText: string;
end;
tAndorInputDateiInfo = class (tGenerischeInputDateiInfo)
temperatur,belichtungsZeit,
@@ -84,15 +84,15 @@ type
tGenerischeInputDateiInfoArray = specialize tArray<tGenerischeInputDateiInfo>;
tInputDateiInfoVorlagen = class
private
- _Name,_Fehlerbehebungskommando: string;
- _Gamma,_groeszenFaktor,
- _tstart,_tstop,_xstart,_xstop: extended;
- _Genauigkeit: tGenauigkeit;
- _tsiz,_xsteps,_SpurNummer,_t0abs,
- _bytesPerSample,_FeldNummer: longint;
- _Analysator: string;
+ _name,_fehlerBehebungsKommando: string;
+ _gamma,_groeszenFaktor,
+ _tStart,_tStop,_xStart,_xStop: extended;
+ _genauigkeit: tGenauigkeit;
+ _tSiz,_xSteps,_spurNummer,_t0abs,
+ _bytesPerSample,_feldNummer: longint;
+ _analysator: string;
_Kodierung: tKodierung;
- _params: tExtrainfos;
+ _params: tExtraInfos;
procedure wFehlerbehebungskommando(f: string);
procedure wName(n: string);
procedure wGamma(g: extended);
@@ -110,71 +110,71 @@ type
procedure wAnalysator(a: string);
procedure wBytesPerSample(b: longint);
procedure wKodierung(k: tKodierung);
- procedure wParams(p: tExtrainfos);
+ procedure wParams(p: tExtraInfos);
public
- PhaseSpaceVorlage: tPhaseSpaceInputDateiInfo;
- SpaceTimeVorlage: tSpaceTimeInputDateiInfo;
- TraceVorlage: tTraceInputDateiInfo;
- SergeyVorlage: tSergeyInputDateiInfo;
- PipeVorlage: tPipeInputDateiInfo;
- AndorVorlage: tAndorInputDateiInfo;
- property Fehlerbehebungskommando: string
- read _Fehlerbehebungskommando
+ phaseSpaceVorlage: tPhaseSpaceInputDateiInfo;
+ spaceTimeVorlage: tSpaceTimeInputDateiInfo;
+ traceVorlage: tTraceInputDateiInfo;
+ sergeyVorlage: tSergeyInputDateiInfo;
+ pipeVorlage: tPipeInputDateiInfo;
+ andorVorlage: tAndorInputDateiInfo;
+ property fehlerBehebungsKommando: string
+ read _fehlerBehebungsKommando
write wFehlerbehebungskommando;
- property Name: string
- read _Name
+ property name: string
+ read _name
write wName;
- property Gamma: extended
- read _Gamma
+ property gamma: extended
+ read _gamma
write wGamma;
- property tstart: extended
- read _tstart
+ property tStart: extended
+ read _tStart
write wTStart;
- property tstop: extended
- read _tstop
+ property tStop: extended
+ read _tStop
write wTStop;
- property xstart: extended
- read _xstart
+ property xStart: extended
+ read _xStart
write wXStart;
- property xstop: extended
- read _xstop
+ property xStop: extended
+ read _xStop
write wXStop;
- property t0abs: longint
+ property t0Abs: longint
read _t0abs
write wT0Abs;
property groeszenFaktor: extended
read _groeszenFaktor
write wGroeszenFaktor;
- property Genauigkeit: tGenauigkeit
- read _Genauigkeit
+ property genauigkeit: tGenauigkeit
+ read _genauigkeit
write wGenauigkeit;
- property SpurNummer: longint
- read _SpurNummer
+ property spurNummer: longint
+ read _spurNummer
write wSpurNummer;
- property FeldNummer: longint
- read _FeldNummer
+ property feldNummer: longint
+ read _feldNummer
write wFeldNummer;
- property Analysator: string
- read _Analysator
+ property analysator: string
+ read _analysator
write wAnalysator;
property bytesPerSample: longint
read _bytesPerSample
write wBytesPerSample;
- property tsiz: longint
- read _tsiz
+ property tSiz: longint
+ read _tSiz
write wTSiz;
- property xsteps: longint
- read _xsteps
+ property xSteps: longint
+ read _xSteps
write wXSteps;
property Kodierung: tKodierung
read _Kodierung
write wKodierung;
- property params: tExtrainfos
+ property params: tExtraInfos
read _params
write wParams;
- function GenauigkeitFromStr(s: string): boolean;
- function Fehlerbehebungsprogramm: string;
- function Fehlerbehebungsparameter: string;
+ function genauigkeitFromStr(s: string): boolean;
+ function fehlerBehebungsProgramm: string;
+ function fehlerBehebungsParameter: string;
constructor create;
destructor destroy; override;
end;
@@ -194,10 +194,10 @@ type
pTBeschriftungen = ^tBeschriftungen;
tLage = (lLinks,lOben,lRechts,lUnten);
tFenster = class
- procedure testeFensterdurchschnitt(schlussBeiWenigInhalt: boolean);
+ procedure testeFensterDurchschnitt(schlussBeiWenigInhalt: boolean);
public
aktiv: boolean;
- Werte: tExtendedArray;
+ werte: tExtendedArray;
constructor create;
destructor destroy; override;
procedure berechneWerte(anzWerte: longint; schlussBeiWenigInhalt: boolean = false); virtual; abstract; overload;
@@ -223,7 +223,7 @@ type
lage: tLage;
fontRend: tFontRenderer;
bBreite,bHoehe: longint;
- Rahmen: boolean;
+ rahmen: boolean;
position: extended;
bild: tLLBild;
property inhalt: string
@@ -246,14 +246,14 @@ type
procedure wTransformationen(tr: tTransformation);
public
maxW,minW,np,beta: extended;
- tsiz,xsteps,tsiz_,xsteps_: longint;
+ tSiz,xSteps,tSiz_,xSteps_: longint;
knownValues: tKnownValues;
constructor create;
destructor destroy; override;
- function xstart: extended;
- function xstop: extended;
- function tstart: extended;
- function tstop: extended;
+ function xStart: extended;
+ function xStop: extended;
+ function tStart: extended;
+ function tStop: extended;
procedure refreshKnownValues;
property transformationen: tTransformation read _transformationen write wTransformationen;
end;
@@ -263,10 +263,10 @@ type
// selbst nicht zum Instanziieren gedacht
private
vorgaenger,nachfolger: array of tTransformation;
- in_xs_ts,out_xs_ts: tIntPoint;
- in_achsen,out_achsen: t2x2Extended;
- in_wmia,out_wmia: tExtPoint;
- wmiaExplizit: boolean; // wmia wurde explizit gesetzt
+ inXSTS,outXSTS: tIntPoint;
+ inAchsen,outAchsen: t2x2Extended;
+ inWMia,outWMia: tExtPoint;
+ wmiaExplizit: boolean; // wMia wurde explizit gesetzt
_anzZugehoerigerDaten: longint;
procedure testeAuszerhalb(const p: tExtPoint);
@@ -277,27 +277,27 @@ type
procedure aktualisiereWmia; virtual;
function transformiereKoordinatenEinzeln(const p: tExtPoint): tExtPoint; virtual;
- // wie ändert sich die Position eines Punktes (Paradebeispiel: bei Spiegelung: x -> xsteps-1-x)
+ // wie ändert sich die Position eines Punktes (Paradebeispiel: bei Spiegelung: x -> xSteps-1-x)
// ist für p veranwortlich?
function transformiereWertEinzeln(const x: extended): extended; virtual;
// wie ändert sich ein Wert
- function rXstart: extended;
- procedure wXstart(x: extended);
- function rXstop: extended;
- procedure wXstop(x: extended);
- function rTstart: extended;
- procedure wTstart(t: extended);
- function rTstop: extended;
- procedure wTstop(t: extended);
- function rWmin: extended;
- procedure wWmin(w: extended);
- function rWmax: extended;
- procedure wWmax(w: extended);
- function rXsteps: longint;
- procedure wXsteps(x: longint);
- function rTsiz: longint;
- procedure wTsiz(t: longint);
+ function rXStart: extended;
+ procedure wXStart(x: extended);
+ function rXStop: extended;
+ procedure wXStop(x: extended);
+ function rTStart: extended;
+ procedure wTStart(t: extended);
+ function rTStop: extended;
+ procedure wTStop(t: extended);
+ function rWMin: extended;
+ procedure wWMin(w: extended);
+ function rWMax: extended;
+ procedure wWMax(w: extended);
+ function rXSteps: longint;
+ procedure wXSteps(x: longint);
+ function rTSiz: longint;
+ procedure wTSiz(t: longint);
public
constructor create;
destructor destroy; override;
@@ -314,40 +314,40 @@ type
procedure erhoeheZugehoerigkeitsanzahl;
procedure verringereZugehoerigkeitsanzahl;
- property achsen: t2x2Extended read out_achsen;
- // wie lauten xstart,xstop,tstart,tstop?
+ property achsen: t2x2Extended read outAchsen;
+ // wie lauten xStart,xStop,tStart,tStop?
function transformiereKoordinaten(const p: tExtPoint; const tiefe: longint = -1): tExtPoint; overload;
function transformiereKoordinaten(const x,y: longint; const tiefe: longint = -1): tExtPoint; overload;
function wertZuPositionAufAchse(const l: tLage; x: extended): extended; virtual;
function transformiereWert(const x: extended; const tiefe: longint = -1): extended;
- property xsteps_tsiz: tIntPoint read out_xs_ts;
- property wmia: tExtPoint read out_wmia;
+ property xStepsTSiz: tIntPoint read outXSTS;
+ property wMia: tExtPoint read outWMia;
function dumpParams: string; virtual; overload;
function dumpParams(tiefe: longint): string; overload;
- property xstart: extended
- read rXstart
- write wXstart;
- property xstop: extended
- read rXstop
- write wXstop;
- property tstart: extended
- read rTstart
- write wTstart;
- property tstop: extended
- read rTstop
- write wTstop;
- property wmin: extended
- read rWmin
- write wWmin;
- property wmax: extended
- read rWmax
- write wWmax;
- property xsteps: longint
- read rXsteps
- write wXsteps;
- property tsiz: longint
- read rTsiz
- write wTsiz;
+ property xStart: extended
+ read rXStart
+ write wXStart;
+ property xStop: extended
+ read rXStop
+ write wXStop;
+ property tStart: extended
+ read rTStart
+ write wTStart;
+ property tStop: extended
+ read rTStop
+ write wTStop;
+ property wMin: extended
+ read rWMin
+ write wWMin;
+ property wMax: extended
+ read rWMax
+ write wWMax;
+ property xSteps: longint
+ read rXSteps
+ write wXSteps;
+ property tSiz: longint
+ read rTSiz
+ write wTSiz;
end;
tKeineTransformation = class (tTransformation)
// der Beginn einer Transformationskette, z.B. das Laden von Daten
@@ -388,7 +388,7 @@ type
tKonkreteKoordinatenTransformation = class (tKoordinatenTransformation)
private
// eine konkrete Verzerrung der Koordinaten (linearer + logarithmischer + exponentieller Anteil)
- function findeLineareParameter(syntaxtest: boolean; auszenSkala: char; s: string; xscale,yscale: extended; var off,xl,yl: extended; ueberschreiben: boolean; etf: tExprToFloat): boolean;
+ function findeLineareParameter(syntaxtest: boolean; auszenSkala: char; s: string; xScale,yScale: extended; var off,xl,yl: extended; ueberschreiben: boolean; etf: tExprToFloat): boolean;
public
lnInt, // Faktoren in den ln-Argumenten
expExp, // Exponenten der Exponentialfunktionen
@@ -399,7 +399,7 @@ type
expFak: tExtPoint; // Vorfaktoren der Exponentialfunktionen
constructor create; overload;
function transformiereKoordinatenEinzeln(const p: tExtPoint): tExtPoint; override; overload;
- function initAbbildung(syntaxtest: boolean; s: string; xscale,yscale: extended; etf: tExprToFloat): boolean;
+ function initAbbildung(syntaxtest: boolean; s: string; xScale,yScale: extended; etf: tExprToFloat): boolean;
function zielausdehnung: t2x2Longint;
procedure aktualisiereXsTs; override;
// keine Änderung der Achsenbegrenzungen, der Werte(skalierung)
@@ -419,7 +419,7 @@ type
tKoordinatenAusschnitt = class (tKoordinatenTransformation)
gr: t2x2Longint;
constructor create; overload;
- constructor create(vorg: tTransformation; xmin,xmax,tmin,tmax: longint); overload;
+ constructor create(vorg: tTransformation; xMin,xMax,tMin,tMax: longint); overload;
procedure aktualisiereXsTs; override;
procedure aktualisiereAchsen; override;
function transformiereKoordinatenEinzeln(const p: tExtPoint): tExtPoint; override; overload;
@@ -506,7 +506,7 @@ type
function dumpParams: string; override;
end;
-function liesTWerteTransformationen(st: boolean; s: string; f: tMyStringlist; etf: tExprToFloat; var tr: tTransformation): boolean;
+function liesTWerteTransformationen(sT: boolean; s: string; f: tMyStringList; etf: tExprToFloat; var tr: tTransformation): boolean;
procedure zerstoereTransformationWennObsolet(tr: tTransformation);
function dreheLagePositiv(l: tLage): tLage; inline;
@@ -517,78 +517,78 @@ implementation
constructor tGenerischeInputDateiInfo.create(Vorlage: tGenerischeInputDateiInfo);
begin
inherited create;
- fillchar(Name,sizeof(Name),#0);
- Name:=Vorlage.Name;
- fillchar(Fehlerbehebungskommando,sizeof(Fehlerbehebungskommando),#0);
- Fehlerbehebungskommando:=Vorlage.Fehlerbehebungskommando;
+ fillchar(name,sizeOf(name),#0);
+ name:=Vorlage.name;
+ fillchar(fehlerBehebungsKommando,sizeOf(fehlerBehebungsKommando),#0);
+ fehlerBehebungsKommando:=Vorlage.fehlerBehebungsKommando;
gamma:=Vorlage.gamma;
groeszenFaktor:=Vorlage.groeszenFaktor;
- Genauigkeit:=Vorlage.Genauigkeit;
- tsiz:=Vorlage.tsiz;
- xsteps:=Vorlage.xsteps;
- tstart:=Vorlage.tstart;
- tstop:=Vorlage.tstop;
- xstart:=Vorlage.xstart;
- xstop:=Vorlage.xstop;
+ genauigkeit:=Vorlage.genauigkeit;
+ tSiz:=Vorlage.tSiz;
+ xSteps:=Vorlage.xSteps;
+ tStart:=Vorlage.tStart;
+ tStop:=Vorlage.tStop;
+ xStart:=Vorlage.xStart;
+ xStop:=Vorlage.xStop;
params:=Vorlage.params;
- t0abs:=Vorlage.t0abs;
+ t0Abs:=Vorlage.t0Abs;
end;
constructor tGenerischeInputDateiInfo.create;
begin
inherited create;
- fillchar(Name,sizeof(Name),#0);
- Name:='';
- fillchar(Fehlerbehebungskommando,sizeof(Fehlerbehebungskommando),#0);
- Fehlerbehebungskommando:='';
+ fillchar(name,sizeOf(name),#0);
+ name:='';
+ fillchar(fehlerBehebungsKommando,sizeOf(fehlerBehebungsKommando),#0);
+ fehlerBehebungsKommando:='';
gamma:=1;
groeszenFaktor:=1;
- Genauigkeit:=gSingle;
- tsiz:=-1;
- t0abs:=-1;
- xsteps:=-1;
- tstart:=-myInf;
- tstop:=myInf;
- xstart:=-myInf;
- xstop:=myInf;
+ genauigkeit:=gSingle;
+ tSiz:=-1;
+ t0Abs:=-1;
+ xSteps:=-1;
+ tStart:=-myInf;
+ tStop:=myInf;
+ xStart:=-myInf;
+ xStop:=myInf;
params:=nil;
end;
destructor tGenerischeInputDateiInfo.destroy;
begin
- Name:='';
- Fehlerbehebungskommando:='';
+ name:='';
+ fehlerBehebungsKommando:='';
inherited destroy;
end;
-function tGenerischeInputDateiInfo.xmin: longint;
+function tGenerischeInputDateiInfo.xMin: longint;
begin
result:=0;
- if assigned(params) and (params.xsteps>1) and (xstart > params.xstart + result/(params.xsteps-1)*(params.xstop-params.xstart)) then
- result:=min(xsteps-1,round((xstart-params.xstart)/(params.xstop-params.xstart)/(params.xsteps-1)));
+ if assigned(params) and (params.xSteps>1) and (xStart > params.xStart + result/(params.xSteps-1)*(params.xStop-params.xStart)) then
+ result:=min(xSteps-1,round((xStart-params.xStart)/(params.xStop-params.xStart)/(params.xSteps-1)));
end;
-function tGenerischeInputDateiInfo.xmax: longint;
+function tGenerischeInputDateiInfo.xMax: longint;
begin
- result:=xsteps-1;
- if assigned(params) and (params.xsteps>1) and (xstop < params.xstart + result/(params.xsteps-1)*(params.xstop-params.xstart)) then
- result:=max(0,round((xstop-params.xstart)/(params.xstop-params.xstart)/(params.xsteps-1)));
+ result:=xSteps-1;
+ if assigned(params) and (params.xSteps>1) and (xStop < params.xStart + result/(params.xSteps-1)*(params.xStop-params.xStart)) then
+ result:=max(0,round((xStop-params.xStart)/(params.xStop-params.xStart)/(params.xSteps-1)));
end;
-function tGenerischeInputDateiInfo.tmin: longint;
+function tGenerischeInputDateiInfo.tMin: longint;
begin
- result:=t0abs;
- if assigned(params) and (params.tsiz>1) and (tstart > params.tstart + result/(params.tsiz-1)*(params.tstop-params.tstart)) then
- result:=round((tstart-params.tstart)/(params.tstop-params.tstart)/(params.tsiz-1));
- result:=min(tsiz-1,max(0,result-t0abs));
+ result:=t0Abs;
+ if assigned(params) and (params.tSiz>1) and (tStart > params.tStart + result/(params.tSiz-1)*(params.tStop-params.tStart)) then
+ result:=round((tStart-params.tStart)/(params.tStop-params.tStart)/(params.tSiz-1));
+ result:=min(tSiz-1,max(0,result-t0Abs));
end;
-function tGenerischeInputDateiInfo.tmax: longint;
+function tGenerischeInputDateiInfo.tMax: longint;
begin
- result:=t0abs+tsiz-1;
- if assigned(params) and (params.tsiz>1) and (tstop < params.tstart + result/(params.tsiz-1)*(params.tstop-params.tstart)) then
- result:=round((tstop-params.tstart)/(params.tstop-params.tstart)/(params.tsiz-1));
- result:=min(tsiz-1,max(0,result-t0abs));
+ result:=t0Abs+tSiz-1;
+ if assigned(params) and (params.tSiz>1) and (tStop < params.tStart + result/(params.tSiz-1)*(params.tStop-params.tStart)) then
+ result:=round((tStop-params.tStart)/(params.tStop-params.tStart)/(params.tSiz-1));
+ result:=min(tSiz-1,max(0,result-t0Abs));
end;
// tPhaseSpaceInputDateiInfo ****************************************************
@@ -631,20 +631,20 @@ constructor tTraceInputDateiInfo.create(Vorlage: tGenerischeInputDateiInfo);
begin
inherited create(Vorlage);
if Vorlage is tTraceInputDateiInfo then begin
- Spurnummer:=(Vorlage as tTraceInputDateiInfo).Spurnummer;
- FeldNummer:=(Vorlage as tTraceInputDateiInfo).FeldNummer;
+ spurNummer:=(Vorlage as tTraceInputDateiInfo).spurNummer;
+ feldNummer:=(Vorlage as tTraceInputDateiInfo).feldNummer;
end
else begin
- Spurnummer:=0;
- FeldNummer:=0;
+ spurNummer:=0;
+ feldNummer:=0;
end;
end;
constructor tTraceInputDateiInfo.create;
begin
inherited create;
- Spurnummer:=0;
- FeldNummer:=0;
+ spurNummer:=0;
+ feldNummer:=0;
end;
destructor tTraceInputDateiInfo.destroy;
@@ -658,15 +658,15 @@ constructor tSergeyInputDateiInfo.create(Vorlage: tGenerischeInputDateiInfo);
begin
inherited create(Vorlage);
if Vorlage is tSergeyInputDateiInfo then
- FeldNummer:=(Vorlage as tSergeyInputDateiInfo).FeldNummer
+ feldNummer:=(Vorlage as tSergeyInputDateiInfo).feldNummer
else
- FeldNummer:=0;
+ feldNummer:=0;
end;
constructor tSergeyInputDateiInfo.create;
begin
inherited create;
- FeldNummer:=0;
+ feldNummer:=0;
end;
destructor tSergeyInputDateiInfo.destroy;
@@ -679,14 +679,14 @@ end;
constructor tPipeInputDateiInfo.create(Vorlage: tGenerischeInputDateiInfo);
begin
inherited create(Vorlage);
- fillchar(Analysator,sizeof(Analysator),#0);
+ fillchar(analysator,sizeOf(analysator),#0);
if Vorlage is tPipeInputDateiInfo then begin
- Analysator:=(Vorlage as tPipeInputDateiInfo).Analysator;
+ analysator:=(Vorlage as tPipeInputDateiInfo).analysator;
bytesPerSample:=(Vorlage as tPipeInputDateiInfo).bytesPerSample;
Kodierung:=(Vorlage as tPipeInputDateiInfo).Kodierung;
end
else begin
- Analysator:='/usr/bin/soxi -';
+ analysator:='/usr/bin/soxi -';
bytesPerSample:=-1;
Kodierung:=kUnbekannt;
end;
@@ -695,38 +695,38 @@ end;
constructor tPipeInputDateiInfo.create;
begin
inherited create;
- fillchar(Analysator,sizeof(Analysator),#0);
- Analysator:='/usr/bin/soxi -';
+ fillchar(analysator,sizeOf(analysator),#0);
+ analysator:='/usr/bin/soxi -';
bytesPerSample:=-1;
Kodierung:=kUnbekannt;
end;
destructor tPipeInputDateiInfo.destroy;
begin
- Analysator:='';
+ analysator:='';
inherited destroy;
end;
-function tPipeInputDateiInfo.Executable: string;
+function tPipeInputDateiInfo.executable: string;
begin
- result:=leftStr(Name,pos(' ',Name+' ')-1);
+ result:=leftStr(name,pos(' ',name+' ')-1);
end;
-function tPipeInputDateiInfo.ParametersText: string;
+function tPipeInputDateiInfo.parametersText: string;
begin
- result:=copy(Name,pos(' ',Name+' ')+1,length(Name));
+ result:=copy(name,pos(' ',name+' ')+1,length(name));
while pos(' ',result)>0 do
result[pos(' ',result)]:=#13;
end;
-function tPipeInputDateiInfo.AnalysatorExecutable: string;
+function tPipeInputDateiInfo.analysatorExecutable: string;
begin
- result:=leftStr(Analysator,pos(' ',Analysator+' ')-1);
+ result:=leftStr(analysator,pos(' ',analysator+' ')-1);
end;
-function tPipeInputDateiInfo.AnalysatorParametersText: string;
+function tPipeInputDateiInfo.analysatorParametersText: string;
begin
- result:=copy(Analysator,pos(' ',Analysator+' ')+1,length(Analysator));
+ result:=copy(analysator,pos(' ',analysator+' ')+1,length(analysator));
while pos(' ',result)>0 do
result[pos(' ',result)]:=#13;
end;
@@ -827,234 +827,234 @@ end;
constructor tInputDateiInfoVorlagen.create;
begin
inherited create;
- PhaseSpaceVorlage:=tPhaseSpaceInputDateiInfo.create;
- SpaceTimeVorlage:=tSpaceTimeInputDateiInfo.create;
- TraceVorlage:=tTraceInputDateiInfo.create;
- SergeyVorlage:=tSergeyInputDateiInfo.create;
- PipeVorlage:=tPipeInputDateiInfo.create;
- AndorVorlage:=tAndorInputDateiInfo.create;
- fillchar(_Name,sizeof(_Name),#0);
- Name:=SpaceTimeVorlage.Name;
- fillchar(_Fehlerbehebungskommando,sizeof(_Fehlerbehebungskommando),#0);
- Fehlerbehebungskommando:=SpaceTimeVorlage.Fehlerbehebungskommando;
- Gamma:=SpaceTimeVorlage.Gamma;
- groeszenFaktor:=SpaceTimeVorlage.groeszenFaktor;
- Genauigkeit:=SpaceTimeVorlage.Genauigkeit;
- _tsiz:=SpaceTimeVorlage.tsiz;
- _xsteps:=SpaceTimeVorlage.xsteps;
- SpurNummer:=TraceVorlage.SpurNummer;
- FeldNummer:=TraceVorlage.FeldNummer;
- fillchar(_Analysator,sizeof(_Analysator),#0);
- Analysator:=PipeVorlage.Analysator;
- _bytesPerSample:=PipeVorlage.bytesPerSample;
- _Kodierung:=PipeVorlage.Kodierung;
- _tstart:=SpaceTimeVorlage.tstart;
- _tstop:=SpaceTimeVorlage.tstop;
- _xstart:=SpaceTimeVorlage.xstart;
- _xstop:=SpaceTimeVorlage.xstop;
- _t0abs:=SpaceTimeVorlage.t0abs;
+ phaseSpaceVorlage:=tPhaseSpaceInputDateiInfo.create;
+ spaceTimeVorlage:=tSpaceTimeInputDateiInfo.create;
+ traceVorlage:=tTraceInputDateiInfo.create;
+ sergeyVorlage:=tSergeyInputDateiInfo.create;
+ pipeVorlage:=tPipeInputDateiInfo.create;
+ andorVorlage:=tAndorInputDateiInfo.create;
+ fillchar(_name,sizeOf(_name),#0);
+ name:=spaceTimeVorlage.name;
+ fillchar(_fehlerBehebungsKommando,sizeOf(_fehlerBehebungsKommando),#0);
+ fehlerBehebungsKommando:=spaceTimeVorlage.fehlerBehebungsKommando;
+ gamma:=spaceTimeVorlage.gamma;
+ groeszenFaktor:=spaceTimeVorlage.groeszenFaktor;
+ genauigkeit:=spaceTimeVorlage.genauigkeit;
+ _tSiz:=spaceTimeVorlage.tSiz;
+ _xSteps:=spaceTimeVorlage.xSteps;
+ spurNummer:=traceVorlage.spurNummer;
+ feldNummer:=traceVorlage.feldNummer;
+ fillchar(_analysator,sizeOf(_analysator),#0);
+ analysator:=pipeVorlage.analysator;
+ _bytesPerSample:=pipeVorlage.bytesPerSample;
+ _Kodierung:=pipeVorlage.Kodierung;
+ _tStart:=spaceTimeVorlage.tStart;
+ _tStop:=spaceTimeVorlage.tStop;
+ _xStart:=spaceTimeVorlage.xStart;
+ _xStop:=spaceTimeVorlage.xStop;
+ _t0abs:=spaceTimeVorlage.t0Abs;
end;
destructor tInputDateiInfoVorlagen.destroy;
begin
- PhaseSpaceVorlage.free;
- SpaceTimeVorlage.free;
- TraceVorlage.free;
- SergeyVorlage.free;
- PipeVorlage.free;
- AndorVorlage.free;
- _Name:='';
- _Fehlerbehebungskommando:='';
- _Analysator:='';
+ phaseSpaceVorlage.free;
+ spaceTimeVorlage.free;
+ traceVorlage.free;
+ sergeyVorlage.free;
+ pipeVorlage.free;
+ andorVorlage.free;
+ _name:='';
+ _fehlerBehebungsKommando:='';
+ _analysator:='';
inherited destroy;
end;
procedure tInputDateiInfoVorlagen.wFehlerbehebungskommando(f: string);
begin
- _Fehlerbehebungskommando:=f;
- PhaseSpaceVorlage.Fehlerbehebungskommando:=f;
- SpaceTimeVorlage.Fehlerbehebungskommando:=f;
- TraceVorlage.Fehlerbehebungskommando:=f;
- SergeyVorlage.Fehlerbehebungskommando:=f;
- PipeVorlage.Fehlerbehebungskommando:=f;
- AndorVorlage.Fehlerbehebungskommando:=f;
+ _fehlerBehebungsKommando:=f;
+ phaseSpaceVorlage.fehlerBehebungsKommando:=f;
+ spaceTimeVorlage.fehlerBehebungsKommando:=f;
+ traceVorlage.fehlerBehebungsKommando:=f;
+ sergeyVorlage.fehlerBehebungsKommando:=f;
+ pipeVorlage.fehlerBehebungsKommando:=f;
+ andorVorlage.fehlerBehebungsKommando:=f;
end;
procedure tInputDateiInfoVorlagen.wName(n: string);
begin
- _Name:=n;
- PhaseSpaceVorlage.Name:=n;
- SpaceTimeVorlage.Name:=n;
- TraceVorlage.Name:=n;
- SergeyVorlage.Name:=n;
- PipeVorlage.Name:=n;
- AndorVorlage.Name:=n;
+ _name:=n;
+ phaseSpaceVorlage.name:=n;
+ spaceTimeVorlage.name:=n;
+ traceVorlage.name:=n;
+ sergeyVorlage.name:=n;
+ pipeVorlage.name:=n;
+ andorVorlage.name:=n;
end;
procedure tInputDateiInfoVorlagen.wGamma(g: extended);
begin
- _Gamma:=g;
- PhaseSpaceVorlage.Gamma:=g;
- SpaceTimeVorlage.Gamma:=g;
- TraceVorlage.Gamma:=g;
- SergeyVorlage.Gamma:=g;
- PipeVorlage.Gamma:=g;
+ _gamma:=g;
+ phaseSpaceVorlage.gamma:=g;
+ spaceTimeVorlage.gamma:=g;
+ traceVorlage.gamma:=g;
+ sergeyVorlage.gamma:=g;
+ pipeVorlage.gamma:=g;
end;
procedure tInputDateiInfoVorlagen.wTStart(t: extended);
begin
- _tstart:=t;
- PhaseSpaceVorlage.tstart:=t;
- SpaceTimeVorlage.tstart:=t;
- TraceVorlage.tstart:=t;
- SergeyVorlage.tstart:=t;
- PipeVorlage.tstart:=t;
- AndorVorlage.tstart:=t;
+ _tStart:=t;
+ phaseSpaceVorlage.tStart:=t;
+ spaceTimeVorlage.tStart:=t;
+ traceVorlage.tStart:=t;
+ sergeyVorlage.tStart:=t;
+ pipeVorlage.tStart:=t;
+ andorVorlage.tStart:=t;
end;
procedure tInputDateiInfoVorlagen.wTStop(t: extended);
begin
- _tstop:=t;
- PhaseSpaceVorlage.tstop:=t;
- SpaceTimeVorlage.tstop:=t;
- TraceVorlage.tstop:=t;
- SergeyVorlage.tstop:=t;
- PipeVorlage.tstop:=t;
- AndorVorlage.tstop:=t;
+ _tStop:=t;
+ phaseSpaceVorlage.tStop:=t;
+ spaceTimeVorlage.tStop:=t;
+ traceVorlage.tStop:=t;
+ sergeyVorlage.tStop:=t;
+ pipeVorlage.tStop:=t;
+ andorVorlage.tStop:=t;
end;
procedure tInputDateiInfoVorlagen.wXStart(x: extended);
begin
- _xstart:=x;
- PhaseSpaceVorlage.xstart:=x;
- SpaceTimeVorlage.xstart:=x;
- TraceVorlage.xstart:=x;
- SergeyVorlage.xstart:=x;
- PipeVorlage.xstart:=x;
- AndorVorlage.xstart:=x;
+ _xStart:=x;
+ phaseSpaceVorlage.xStart:=x;
+ spaceTimeVorlage.xStart:=x;
+ traceVorlage.xStart:=x;
+ sergeyVorlage.xStart:=x;
+ pipeVorlage.xStart:=x;
+ andorVorlage.xStart:=x;
end;
procedure tInputDateiInfoVorlagen.wXStop(x: extended);
begin
- _xstop:=x;
- PhaseSpaceVorlage.xstop:=x;
- SpaceTimeVorlage.xstop:=x;
- TraceVorlage.xstop:=x;
- SergeyVorlage.xstop:=x;
- PipeVorlage.xstop:=x;
- AndorVorlage.xstop:=x;
+ _xStop:=x;
+ phaseSpaceVorlage.xStop:=x;
+ spaceTimeVorlage.xStop:=x;
+ traceVorlage.xStop:=x;
+ sergeyVorlage.xStop:=x;
+ pipeVorlage.xStop:=x;
+ andorVorlage.xStop:=x;
end;
procedure tInputDateiInfoVorlagen.wT0Abs(t: longint);
begin
_t0abs:=t;
- PhaseSpaceVorlage.t0abs:=t;
- SpaceTimeVorlage.t0abs:=t;
- TraceVorlage.t0abs:=t;
- SergeyVorlage.t0abs:=t;
- PipeVorlage.t0abs:=t;
- AndorVorlage.t0abs:=t;
+ phaseSpaceVorlage.t0Abs:=t;
+ spaceTimeVorlage.t0Abs:=t;
+ traceVorlage.t0Abs:=t;
+ sergeyVorlage.t0Abs:=t;
+ pipeVorlage.t0Abs:=t;
+ andorVorlage.t0Abs:=t;
end;
procedure tInputDateiInfoVorlagen.wGroeszenFaktor(g: extended);
begin
_groeszenFaktor:=g;
- PhaseSpaceVorlage.groeszenFaktor:=g;
- SpaceTimeVorlage.groeszenFaktor:=g;
- TraceVorlage.groeszenFaktor:=g;
- SergeyVorlage.groeszenFaktor:=g;
- PipeVorlage.groeszenFaktor:=g;
+ phaseSpaceVorlage.groeszenFaktor:=g;
+ spaceTimeVorlage.groeszenFaktor:=g;
+ traceVorlage.groeszenFaktor:=g;
+ sergeyVorlage.groeszenFaktor:=g;
+ pipeVorlage.groeszenFaktor:=g;
end;
procedure tInputDateiInfoVorlagen.wGenauigkeit(g: tGenauigkeit);
begin
- _Genauigkeit:=g;
- PhaseSpaceVorlage.Genauigkeit:=g;
- SpaceTimeVorlage.Genauigkeit:=g;
- TraceVorlage.Genauigkeit:=g;
- SergeyVorlage.Genauigkeit:=g;
- PipeVorlage.Genauigkeit:=g;
- AndorVorlage.Genauigkeit:=g;
+ _genauigkeit:=g;
+ phaseSpaceVorlage.genauigkeit:=g;
+ spaceTimeVorlage.genauigkeit:=g;
+ traceVorlage.genauigkeit:=g;
+ sergeyVorlage.genauigkeit:=g;
+ pipeVorlage.genauigkeit:=g;
+ andorVorlage.genauigkeit:=g;
end;
procedure tInputDateiInfoVorlagen.wTSiz(t: longint);
begin
- _tsiz:=t;
- PhaseSpaceVorlage.tsiz:=t;
- SpaceTimeVorlage.tsiz:=t;
- TraceVorlage.tsiz:=t;
- SergeyVorlage.tsiz:=t;
- PipeVorlage.tsiz:=t;
- AndorVorlage.tsiz:=t;
+ _tSiz:=t;
+ phaseSpaceVorlage.tSiz:=t;
+ spaceTimeVorlage.tSiz:=t;
+ traceVorlage.tSiz:=t;
+ sergeyVorlage.tSiz:=t;
+ pipeVorlage.tSiz:=t;
+ andorVorlage.tSiz:=t;
end;
procedure tInputDateiInfoVorlagen.wXSteps(x: longint);
begin
- _xsteps:=x;
- PhaseSpaceVorlage.xsteps:=x;
- SpaceTimeVorlage.xsteps:=x;
- TraceVorlage.xsteps:=x;
- SergeyVorlage.xsteps:=x;
- PipeVorlage.xsteps:=x;
- AndorVorlage.xsteps:=x;
+ _xSteps:=x;
+ phaseSpaceVorlage.xSteps:=x;
+ spaceTimeVorlage.xSteps:=x;
+ traceVorlage.xSteps:=x;
+ sergeyVorlage.xSteps:=x;
+ pipeVorlage.xSteps:=x;
+ andorVorlage.xSteps:=x;
end;
procedure tInputDateiInfoVorlagen.wSpurNummer(s: longint);
begin
- _SpurNummer:=s;
- TraceVorlage.SpurNummer:=s;
+ _spurNummer:=s;
+ traceVorlage.spurNummer:=s;
end;
procedure tInputDateiInfoVorlagen.wFeldNummer(f: longint);
begin
- _FeldNummer:=f;
- TraceVorlage.FeldNummer:=f;
- SergeyVorlage.FeldNummer:=f;
+ _feldNummer:=f;
+ traceVorlage.feldNummer:=f;
+ sergeyVorlage.feldNummer:=f;
end;
procedure tInputDateiInfoVorlagen.wAnalysator(a: string);
begin
- _Analysator:=a;
- PipeVorlage.Analysator:=a;
+ _analysator:=a;
+ pipeVorlage.analysator:=a;
end;
procedure tInputDateiInfoVorlagen.wBytesPerSample(b: longint);
begin
_bytesPerSample:=b;
- PipeVorlage.bytesPerSample:=b;
+ pipeVorlage.bytesPerSample:=b;
end;
procedure tInputDateiInfoVorlagen.wKodierung(k: tKodierung);
begin
_Kodierung:=k;
- PipeVorlage.Kodierung:=k;
+ pipeVorlage.Kodierung:=k;
end;
-function tInputDateiInfoVorlagen.GenauigkeitFromStr(s: string): boolean;
+function tInputDateiInfoVorlagen.genauigkeitFromStr(s: string): boolean;
begin
- result:=strToGen(_Genauigkeit,s);
- Genauigkeit:=_Genauigkeit;
+ result:=strToGen(_genauigkeit,s);
+ genauigkeit:=_genauigkeit;
end;
-function tInputDateiInfoVorlagen.Fehlerbehebungsprogramm: string;
+function tInputDateiInfoVorlagen.fehlerBehebungsProgramm: string;
begin
- result:=copy(Fehlerbehebungskommando,1,pos(' ',Fehlerbehebungskommando+' ')-1);
+ result:=copy(fehlerBehebungsKommando,1,pos(' ',fehlerBehebungsKommando+' ')-1);
end;
-function tInputDateiInfoVorlagen.Fehlerbehebungsparameter: string;
+function tInputDateiInfoVorlagen.fehlerBehebungsParameter: string;
begin
- result:=copy(Fehlerbehebungskommando,pos(' ',Fehlerbehebungskommando+' ')+1,length(Fehlerbehebungskommando));
+ result:=copy(fehlerBehebungsKommando,pos(' ',fehlerBehebungsKommando+' ')+1,length(fehlerBehebungsKommando));
end;
-procedure tInputDateiInfoVorlagen.wParams(p: tExtrainfos);
+procedure tInputDateiInfoVorlagen.wParams(p: tExtraInfos);
begin
_params:=p;
- PhaseSpaceVorlage.params:=p;
- SpaceTimeVorlage.params:=p;
- TraceVorlage.params:=p;
- SergeyVorlage.params:=p;
- PipeVorlage.params:=p;
- AndorVorlage.params:=p;
+ phaseSpaceVorlage.params:=p;
+ spaceTimeVorlage.params:=p;
+ traceVorlage.params:=p;
+ sergeyVorlage.params:=p;
+ pipeVorlage.params:=p;
+ andorVorlage.params:=p;
end;
// tFenster ********************************************************************
@@ -1062,17 +1062,17 @@ end;
constructor tFenster.create;
begin
inherited create;
- setlength(werte,0);
+ setLength(werte,0);
aktiv:=false;
end;
destructor tFenster.destroy;
begin
- setlength(werte,0);
+ setLength(werte,0);
inherited destroy;
end;
-procedure tFenster.testeFensterdurchschnitt(schlussBeiWenigInhalt: boolean);
+procedure tFenster.testeFensterDurchschnitt(schlussBeiWenigInhalt: boolean);
var
fenAvg: extended;
i: longint;
@@ -1083,15 +1083,15 @@ begin
fenAvg:=fenAvg/length(werte);
if fenAvg<0.5 then begin
if schlussBeiWenigInhalt then
- fehler('Sehr geringer Fensterdurchschnitt: '+floattostr(fenAvg)+' ('+dumpParams+')!')
+ fehler('Sehr geringer Fensterdurchschnitt: '+floatToStr(fenAvg)+' ('+dumpParams+')!')
else
- gibAus('Sehr geringer Fensterdurchschnitt: '+floattostr(fenAvg)+' ('+dumpParams+')! Ich mache aber trotzdem weiter.',3);
+ gibAus('Sehr geringer Fensterdurchschnitt: '+floatToStr(fenAvg)+' ('+dumpParams+')! Ich mache aber trotzdem weiter.',3);
end;
end;
function tFenster.dumpParams: string;
begin
- result:=inttostr(length(werte))+' Werte ';
+ result:=intToStr(length(werte))+' Werte ';
if not aktiv then
result:=result+'in';
result:=result+'aktiv';
@@ -1102,15 +1102,15 @@ end;
constructor tSin2Fenster.create;
begin
inherited create;
- Breite:=0;
- Rand:=0;
+ breite:=0;
+ rand:=0;
end;
procedure tSin2Fenster.berechneWerte(anzWerte: longint; schlussBeiWenigInhalt: boolean);
var
i: integer;
begin
- setlength(werte,anzWerte);
+ setLength(werte,anzWerte);
for i:=0 to length(werte)-1 do begin
if 2*i < anzWerte - breite - rand then begin
werte[i]:=0;
@@ -1136,8 +1136,8 @@ end;
function tSin2Fenster.dumpParams: string;
begin
result:=
- 'Breite: '+inttostr(breite)+', '+
- 'Rand: '+inttostr(rand)+', '+
+ 'Breite: '+intToStr(breite)+', '+
+ 'Rand: '+intToStr(rand)+', '+
inherited dumpParams;
end;
@@ -1146,14 +1146,14 @@ end;
constructor tGauszFenster.create;
begin
inherited create;
- Breite:=0;
+ breite:=0;
end;
procedure tGauszFenster.berechneWerte(anzWerte: longint; schlussBeiWenigInhalt: boolean = false);
var
i: integer;
begin
- setlength(werte,anzWerte);
+ setLength(werte,anzWerte);
for i:=0 to length(werte)-1 do
werte[i]:=power(2,-sqr(2*(i-anzWerte/2)/breite));
testeFensterDurchschnitt(schlussBeiWenigInhalt);
@@ -1163,7 +1163,7 @@ function tGauszFenster.dumpParams: string;
begin
result:=
'Breite: '+floattostrtrunc(breite,2,true)+', '+
- 'Rand: '+inttostr(rand)+', '+
+ 'Rand: '+intToStr(rand)+', '+
inherited dumpParams;
end;
@@ -1190,8 +1190,8 @@ function tBeschriftung.links: longint;
begin
case lage of
lOben,lUnten: result:=strich-(bild.breite div 2);
- lLinks: result:=-bild.breite-4-Byte(Rahmen);
- lRechts: result:=bbreite+3+Byte(Rahmen);
+ lLinks: result:=-bild.breite-4-byte(rahmen);
+ lRechts: result:=bBreite+3+byte(rahmen);
end{of Case};
end;
@@ -1199,8 +1199,8 @@ function tBeschriftung.oben: longint;
begin
case lage of
lLinks,lRechts: result:=strich-(bild.hoehe div 2);
- lUnten: result:=-bild.hoehe-4-Byte(Rahmen);
- lOben: result:=bHoehe+3+Byte(Rahmen);
+ lUnten: result:=-bild.hoehe-4-byte(rahmen);
+ lOben: result:=bHoehe+3+byte(rahmen);
end{of Case};
end;
@@ -1231,10 +1231,10 @@ begin
transformationen.erhoeheZugehoerigkeitsanzahl;
np:=1;
beta:=0;
- tsiz:=0;
- xsteps:=0;
- tsiz_:=0;
- xsteps_:=0;
+ tSiz:=0;
+ xSteps:=0;
+ tSiz_:=0;
+ xSteps_:=0;
knownValues:=tKnownValues.create;
end;
@@ -1258,36 +1258,36 @@ begin
_transformationen.erhoeheZugehoerigkeitsanzahl;
end;
-function tExtraInfos.xstart: extended;
+function tExtraInfos.xStart: extended;
begin
- result:=transformationen.xstart;
+ result:=transformationen.xStart;
end;
-function tExtraInfos.xstop: extended;
+function tExtraInfos.xStop: extended;
begin
- result:=transformationen.xstop;
+ result:=transformationen.xStop;
end;
-function tExtraInfos.tstart: extended;
+function tExtraInfos.tStart: extended;
begin
- result:=transformationen.tstart;
+ result:=transformationen.tStart;
end;
-function tExtraInfos.tstop: extended;
+function tExtraInfos.tStop: extended;
begin
- result:=transformationen.tstop;
+ result:=transformationen.tStop;
end;
procedure tExtraInfos.refreshKnownValues;
begin
knownValues.add(knownValue('np',np));
- knownValues.add(knownValue('maxw',maxW));
- knownValues.add(knownValue('minw',minW));
+ knownValues.add(knownValue('maxW',maxW));
+ knownValues.add(knownValue('minW',minW));
knownValues.add(knownValue('beta',beta));
- knownValues.add(knownValue('xstart',xstart));
- knownValues.add(knownValue('xstop',xstop));
- knownValues.add(knownValue('tstart',tstart));
- knownValues.add(knownValue('tstop',tstop));
+ knownValues.add(knownValue('xStart',xStart));
+ knownValues.add(knownValue('xStop',xStop));
+ knownValues.add(knownValue('tStart',tStart));
+ knownValues.add(knownValue('tStop',tStop));
end;
// tFontRenderer ***************************************************************
@@ -1296,7 +1296,7 @@ constructor tFontRenderer.create(schriftgroesze: longint);
begin
inherited create;
- gibAus('FontRenderer erzeugen (Schriftgröße '+inttostr(schriftgroesze)+') ...',1);
+ gibAus('FontRenderer erzeugen (Schriftgröße '+intToStr(schriftgroesze)+') ...',1);
New(agg, Construct);
agg^.font('/usr/share/fonts/TTF/DejaVuSans.ttf',schriftgroesze,false,false,RasterFontCache,0.0);
@@ -1313,14 +1313,14 @@ end;
function tFontRenderer.rendere(s: string): tLLBild;
var
buf: array of byte;
- ho,br,ymax,ymin,xmax,xmin,i,j: longint;
+ ho,br,ymax,ymin,xMax,xMin,i,j: longint;
b: boolean;
begin
while pos('.',s)>0 do
s[pos('.',s)]:=',';
br:=4*round(ceil(agg^.textWidth(char_ptr(s))));
ho:=4*round(ceil(agg^.fontHeight));
- setlength(buf,ho*br*4);
+ setLength(buf,ho*br*4);
agg^.attach(@(buf[0]), br, ho, br * 4);
agg^.clearAll(0, 0, 0);
agg^.lineColor(0, 0, 0, 255);
@@ -1359,28 +1359,28 @@ begin
halt(1);
end;
- xmax:=br;
+ xMax:=br;
b:=true;
- while b and (xmax>0) do begin
- dec(xmax);
+ while b and (xMax>0) do begin
+ dec(xMax);
for i:=ymin to ymax do
- if (buf[4*(xmax+br*i)+0]<>$ff) or
- (buf[4*(xmax+br*i)+1]<>$ff) or
- (buf[4*(xmax+br*i)+2]<>$ff) then
+ if (buf[4*(xMax+br*i)+0]<>$ff) or
+ (buf[4*(xMax+br*i)+1]<>$ff) or
+ (buf[4*(xMax+br*i)+2]<>$ff) then
b:=false;
end;
if b then begin
gibAus('Leeres Bild!',3);
halt(1);
end;
- xmin:=-1;
+ xMin:=-1;
b:=true;
- while b and (xmin<=xmax) do begin
- inc(xmin);
+ while b and (xMin<=xMax) do begin
+ inc(xMin);
for i:=ymin to ymax do
- if (buf[4*(xmin+br*i)+0]<>$ff) or
- (buf[4*(xmin+br*i)+1]<>$ff) or
- (buf[4*(xmin+br*i)+2]<>$ff) then
+ if (buf[4*(xMin+br*i)+0]<>$ff) or
+ (buf[4*(xMin+br*i)+1]<>$ff) or
+ (buf[4*(xMin+br*i)+2]<>$ff) then
b:=false;
end;
if b then begin
@@ -1388,20 +1388,20 @@ begin
halt(1);
end;
- dec(xmin);
+ dec(xMin);
dec(ymin);
- inc(xmax);
+ inc(xMax);
inc(ymax);
- result.breite:=xmax-xmin+1;
+ result.breite:=xMax-xMin+1;
result.hoehe:=ymax-ymin+1;
- setlength(result.farben,result.breite*result.hoehe);
+ setLength(result.farben,result.breite*result.hoehe);
for i:=0 to result.breite-1 do
for j:=0 to result.hoehe-1 do begin
- result.farben[i + j*result.breite].rgbBlue:= byte(buf[4*(i+xmin+br*(j+ymin))+0]);
- result.farben[i + j*result.breite].rgbGreen:=byte(buf[4*(i+xmin+br*(j+ymin))+1]);
- result.farben[i + j*result.breite].rgbRed:= byte(buf[4*(i+xmin+br*(j+ymin))+2]);
+ result.farben[i + j*result.breite].rgbBlue:= byte(buf[4*(i+xMin+br*(j+ymin))+0]);
+ result.farben[i + j*result.breite].rgbGreen:=byte(buf[4*(i+xMin+br*(j+ymin))+1]);
+ result.farben[i + j*result.breite].rgbRed:= byte(buf[4*(i+xMin+br*(j+ymin))+2]);
end;
{ for i:=0 to 1 do
for j:=0 to 1 do begin
@@ -1412,7 +1412,7 @@ begin
result.farben[i*(result.breite-1) + j*(result.hoehe-1)*result.breite].rgbBlue:=
result.farben[i*(result.breite-1) + j*(result.hoehe-1)*result.breite].rgbBlue xor $ff;
end; }
- setlength(buf,0);
+ setLength(buf,0);
end;
// tTransformation *************************************************************
@@ -1433,7 +1433,7 @@ begin
vorgaenger[i].loescheNachfolger(self);
zerstoereTransformationWennObsolet(vorgaenger[i]);
end;
- setlength(vorgaenger,0);
+ setLength(vorgaenger,0);
if wirdGebraucht then
fehler('Ich ('+className+') werde noch gebraucht (von '+werBrauchtDas+'), da kann ich mich nicht zerstören!');
inherited destroy;
@@ -1441,156 +1441,156 @@ end;
procedure tTransformation.testeAuszerhalb(const p: tExtPoint);
begin
- if (p['x']<0) or (p['x']>in_xs_ts['x']-1) or
- (p['y']<0) or (p['y']>in_xs_ts['y']-1) then
- fehler('Punkt '+tExtPointToStr(p)+' liegt außerhalb des gültigen Eingabebereich (0..'+inttostr(in_xs_ts['x']-1)+' x 0..'+inttostr(in_xs_ts['y']-1)+')!');
+ if (p['x']<0) or (p['x']>inXSTS['x']-1) or
+ (p['y']<0) or (p['y']>inXSTS['y']-1) then
+ fehler('Punkt '+tExtPointToStr(p)+' liegt außerhalb des gültigen Eingabebereich (0..'+intToStr(inXSTS['x']-1)+' x 0..'+intToStr(inXSTS['y']-1)+')!');
end;
procedure tTransformation.holeInfosVonVorgaengern;
var
i: longint;
begin
- in_achsen:=vorgaenger[0].achsen;
+ inAchsen:=vorgaenger[0].achsen;
for i:=1 to length(vorgaenger)-1 do
- if in_achsen <> vorgaenger[i].achsen then
+ if inAchsen <> vorgaenger[i].achsen then
fehler('Vorgänger haben verschiedene Achsen, was generisch nicht zu verstehen ist!');
- in_xs_ts:=vorgaenger[0].xsteps_tsiz;
+ inXSTS:=vorgaenger[0].xStepsTSiz;
for i:=1 to length(vorgaenger)-1 do
- if in_xs_ts <> vorgaenger[i].xsteps_tsiz then
- fehler('Vorgänger haben verschiedene xsteps oder tsiz, was generisch nicht zu verstehen ist!');
+ if inXSTS <> vorgaenger[i].xStepsTSiz then
+ fehler('Vorgänger haben verschiedene xSteps oder tSiz, was generisch nicht zu verstehen ist!');
if not wmiaExplizit then begin
- in_wmia:=vorgaenger[0].wmia;
+ inWMia:=vorgaenger[0].wMia;
for i:=1 to length(vorgaenger)-1 do
- if in_wmia <> vorgaenger[i].wmia then
+ if inWMia <> vorgaenger[i].wMia then
fehler('Vorgänger haben verschiedene wmin oder wmax, was generisch nicht zu verstehen ist!');
end;
end;
procedure tTransformation.aktualisiereAchsen; // nicht zum direkten Aufrufen
begin
- out_achsen:=in_achsen;
+ outAchsen:=inAchsen;
end;
procedure tTransformation.aktualisiereXsTs; // nicht zum direkten Aufrufen
begin
- out_xs_ts:=in_xs_ts;
+ outXSTS:=inXSTS;
end;
procedure tTransformation.aktualisiereWmia; // nicht zum direkten Aufrufen
begin
if not wmiaExplizit then
- out_wmia:=in_wmia;
+ outWMia:=inWMia;
end;
-function tTransformation.rXstart: extended;
+function tTransformation.rXStart: extended;
begin
- result:=out_achsen['x','x'];
+ result:=outAchsen['x','x'];
end;
-procedure tTransformation.wXstart(x: extended);
+procedure tTransformation.wXStart(x: extended);
begin
if not (self is tKeineTransformation) then
- fehler('Will xstart schreiben, aber bin nicht der Anfang einer Transformationskette!');
- in_achsen['x','x']:=x;
+ fehler('Will xStart schreiben, aber bin nicht der Anfang einer Transformationskette!');
+ inAchsen['x','x']:=x;
aktualisiereAlles;
end;
-function tTransformation.rXstop: extended;
+function tTransformation.rXStop: extended;
begin
- result:=out_Achsen['x','y'];
+ result:=outAchsen['x','y'];
end;
-procedure tTransformation.wXstop(x: extended);
+procedure tTransformation.wXStop(x: extended);
begin
if not (self is tKeineTransformation) then
- fehler('Will xstop schreiben, aber bin nicht der Anfang einer Transformationskette!');
- in_achsen['x','y']:=x;
+ fehler('Will xStop schreiben, aber bin nicht der Anfang einer Transformationskette!');
+ inAchsen['x','y']:=x;
aktualisiereAlles;
end;
-function tTransformation.rTstart: extended;
+function tTransformation.rTStart: extended;
begin
- result:=out_Achsen['y','x'];
+ result:=outAchsen['y','x'];
end;
-procedure tTransformation.wTstart(t: extended);
+procedure tTransformation.wTStart(t: extended);
begin
if not (self is tKeineTransformation) then
- fehler('Will tstart schreiben, aber bin nicht der Anfang einer Transformationskette!');
- in_achsen['y','x']:=t;
+ fehler('Will tStart schreiben, aber bin nicht der Anfang einer Transformationskette!');
+ inAchsen['y','x']:=t;
aktualisiereAlles;
end;
-function tTransformation.rTstop: extended;
+function tTransformation.rTStop: extended;
begin
- result:=out_Achsen['y','y'];
+ result:=outAchsen['y','y'];
end;
-procedure tTransformation.wTstop(t: extended);
+procedure tTransformation.wTStop(t: extended);
begin
if not (self is tKeineTransformation) then
- fehler('Will tstop schreiben, aber bin nicht der Anfang einer Transformationskette!');
- in_achsen['y','y']:=t;
+ fehler('Will tStop schreiben, aber bin nicht der Anfang einer Transformationskette!');
+ inAchsen['y','y']:=t;
aktualisiereAlles;
end;
-function tTransformation.rWmin: extended;
+function tTransformation.rWMin: extended;
begin
- result:=out_wmia['x'];
+ result:=outWMia['x'];
end;
-procedure tTransformation.wWmin(w: extended);
+procedure tTransformation.wWMin(w: extended);
begin
if (self is tAgglomeration) then begin
- if out_wmia['x']<>w then
- fehler('Setzen von wmin für Agglomeration nicht erlaubt ( '+floattostr(w)+' ≠ '+floattostr(out_wmia['x'])+' )!');
+ if outWMia['x']<>w then
+ fehler('Setzen von wMin für Agglomeration nicht erlaubt ( '+floatToStr(w)+' ≠ '+floatToStr(outWMia['x'])+' )!');
exit;
end;
- out_wmia['x']:=w;
+ outWMia['x']:=w;
wmiaExplizit:=true;
aktualisiereAlles;
end;
-function tTransformation.rWmax: extended;
+function tTransformation.rWMax: extended;
begin
- result:=out_wmia['y'];
+ result:=outWMia['y'];
end;
-procedure tTransformation.wWmax(w: extended);
+procedure tTransformation.wWMax(w: extended);
begin
if (self is tAgglomeration) then begin
- if out_wmia['y']<>w then
- fehler('Setzen von wmax für Agglomeration nicht erlaubt ( '+floattostr(w)+' ≠ '+floattostr(out_wmia['y'])+' )!');
+ if outWMia['y']<>w then
+ fehler('Setzen von wMax für Agglomeration nicht erlaubt ( '+floatToStr(w)+' ≠ '+floatToStr(outWMia['y'])+' )!');
exit;
end;
wmiaExplizit:=true;
- out_wmia['y']:=w;
+ outWMia['y']:=w;
aktualisiereAlles;
end;
-function tTransformation.rXsteps: longint;
+function tTransformation.rXSteps: longint;
begin
- result:=out_xs_ts['x'];
+ result:=outXSTS['x'];
end;
-procedure tTransformation.wXsteps(x: longint);
+procedure tTransformation.wXSteps(x: longint);
begin
if not (self is tKeineTransformation) then
- fehler('Will xsteps schreiben, aber bin nicht der Anfang einer Transformationskette!');
- in_xs_ts['x']:=x;
+ fehler('Will xSteps schreiben, aber bin nicht der Anfang einer Transformationskette!');
+ inXSTS['x']:=x;
aktualisiereAlles;
end;
-function tTransformation.rTsiz: longint;
+function tTransformation.rTSiz: longint;
begin
- result:=out_xs_ts['y'];
+ result:=outXSTS['y'];
end;
-procedure tTransformation.wTsiz(t: longint);
+procedure tTransformation.wTSiz(t: longint);
begin
if not (self is tKeineTransformation) then
- fehler('Will tsiz schreiben, aber bin nicht der Anfang einer Transformationskette!');
- in_xs_ts['y']:=t;
+ fehler('Will tSiz schreiben, aber bin nicht der Anfang einer Transformationskette!');
+ inXSTS['y']:=t;
aktualisiereAlles;
end;
@@ -1609,7 +1609,7 @@ end;
procedure tTransformation.fuegeNachfolgerHinzu(tr: tTransformation);
begin
if assigned(tr) then begin
- setlength(nachfolger,length(nachfolger)+1);
+ setLength(nachfolger,length(nachfolger)+1);
nachfolger[length(nachfolger)-1]:=tr;
end;
end;
@@ -1622,7 +1622,7 @@ begin
if nachfolger[i]=tr then begin
for j:=i+1 to length(nachfolger)-1 do
nachfolger[j-1]:=nachfolger[j];
- setlength(nachfolger,length(nachfolger)-1);
+ setLength(nachfolger,length(nachfolger)-1);
exit;
end;
fehler('Kann zu löschenden Nachfolger nicht finden!');
@@ -1631,7 +1631,7 @@ end;
procedure tTransformation.fuegeVorgaengerHinzu(tr: tTransformation);
begin
if assigned(tr) then begin
- setlength(vorgaenger,length(vorgaenger)+1);
+ setLength(vorgaenger,length(vorgaenger)+1);
vorgaenger[length(vorgaenger)-1]:=tr;
tr.fuegeNachfolgerHinzu(self);
end;
@@ -1646,7 +1646,7 @@ begin
if vorgaenger[i]=tr then begin
for j:=i+1 to length(vorgaenger)-1 do
vorgaenger[j-1]:=vorgaenger[j];
- setlength(vorgaenger,length(vorgaenger)-1);
+ setLength(vorgaenger,length(vorgaenger)-1);
tr.loescheNachfolger(self);
exit;
end;
@@ -1701,7 +1701,7 @@ var
i: longint;
begin
if _anzZugehoerigerDaten>0 then
- result:=' '+inttostr(_anzZugehoerigerDaten)+' Daten'
+ result:=' '+intToStr(_anzZugehoerigerDaten)+' Daten'
else
result:='';
for i:=0 to length(nachfolger)-1 do begin
@@ -1750,13 +1750,13 @@ begin
// in Koordinaten umzurechnen
for d:='x' to 'y' do
- p[d]:=p[d] * (in_xs_ts[d]-1);
+ p[d]:=p[d] * (inXSTS[d]-1);
// zu transformieren
p:=transformiereKoordinatenEinzeln(p);
// und in Anteile zurückzurechnen
- result:=p[c]/out_xs_ts[c];
+ result:=p[c]/outXSTS[c];
end;
function tTransformation.transformiereWertEinzeln(const x: extended): extended;
@@ -1787,10 +1787,10 @@ begin
else
for i:=0 to length(vorgaenger)-1 do begin
if length(vorgaenger)>1 then
- result:=result+#13'< '+inttostr(i)+' >';
+ result:=result+#13'< '+intToStr(i)+' >';
result:=result+#13+vorgaenger[i].dumpParams(tiefe-1);
end;
- result:=result+inttostr(tiefe+1)+': '+dumpParams;
+ result:=result+intToStr(tiefe+1)+': '+dumpParams;
end;
// tKeineTransformation ********************************************************
@@ -1805,10 +1805,10 @@ var
begin
// ein Wert am Anfang ist einfach linear zu interpolieren
c:=char(ord('y')-byte(l in [lOben,lUnten]));
- if x=out_achsen[c,'x'] then
+ if x=outAchsen[c,'x'] then
result:=0
else
- result:=(x-out_achsen[c,'x'])/(out_achsen[c,'y']-out_achsen[c,'x'])*(1-1/out_xs_ts[c]);
+ result:=(x-outAchsen[c,'x'])/(outAchsen[c,'y']-outAchsen[c,'x'])*(1-1/outXSTS[c]);
end;
// tIdentitaet *****************************************************************
@@ -1854,19 +1854,19 @@ var
c: char;
begin
if horizontal then begin
- out_achsen['x','x']:=0;
- out_achsen['x','y']:=(in_xs_ts['x']-1)/(in_achsen['x','y']-in_achsen['x','x']);
+ outAchsen['x','x']:=0;
+ outAchsen['x','y']:=(inXSTS['x']-1)/(inAchsen['x','y']-inAchsen['x','x']);
end
else
for c:='x' to 'y' do
- out_achsen['x',c]:=in_achsen['x',c];
+ outAchsen['x',c]:=inAchsen['x',c];
if vertikal then begin
- out_achsen['y','x']:=0;
- out_achsen['y','y']:=(in_xs_ts['y']-1)/(in_achsen['y','y']-in_achsen['y','x']);
+ outAchsen['y','x']:=0;
+ outAchsen['y','y']:=(inXSTS['y']-1)/(inAchsen['y','y']-inAchsen['y','x']);
end
else
for c:='x' to 'y' do
- out_achsen['y',c]:=in_achsen['y',c];
+ outAchsen['y',c]:=inAchsen['y',c];
end;
function tFFTTransformation.wertZuPositionAufAchse(const l: tLage; x: extended): extended;
@@ -1879,12 +1879,12 @@ begin
else begin
// egal, wie die Werte vor der FFT aussahen, wir setzen die Frequenzen danach linear
c:=char(ord('y')-byte(l in [lOben,lUnten]));
- if x=out_achsen[c,'x'] then
+ if x=outAchsen[c,'x'] then
result:=0
else
- result:=(x-out_achsen[c,'x'])/(out_achsen[c,'y']-out_achsen[c,'x']);
+ result:=(x-outAchsen[c,'x'])/(outAchsen[c,'y']-outAchsen[c,'x']);
- result:=result*(1-1/out_xs_ts[c]);
+ result:=result*(1-1/outXSTS[c]);
end;
end;
@@ -1911,7 +1911,7 @@ end;
function tSpiegelungsTransformation.transformiereKoordinatenEinzeln(const p: tExtPoint): tExtPoint;
begin
testeAuszerhalb(p);
- result['x']:=in_xs_ts['x']-1-p['x'];
+ result['x']:=inXSTS['x']-1-p['x'];
result['y']:=p['y'];
end;
@@ -1939,7 +1939,7 @@ begin
end;
end;
-function tKonkreteKoordinatenTransformation.findeLineareParameter(syntaxtest: boolean; auszenSkala: char; s: string; xscale,yscale: extended; var off,xl,yl: extended; ueberschreiben: boolean; etf: tExprToFloat): boolean;
+function tKonkreteKoordinatenTransformation.findeLineareParameter(syntaxtest: boolean; auszenSkala: char; s: string; xScale,yScale: extended; var off,xl,yl: extended; ueberschreiben: boolean; etf: tExprToFloat): boolean;
var
t: string;
c: char;
@@ -1970,12 +1970,12 @@ begin
else try
tmp:=etf(syntaxtest,t);
case c of
- 'x': tmp:=tmp*xscale;
- 'y': tmp:=tmp*yscale;
+ 'x': tmp:=tmp*xScale;
+ 'y': tmp:=tmp*yScale;
end;
case auszenSkala of
- 'x': tmp:=tmp/xscale;
- 'y': tmp:=tmp/yscale;
+ 'x': tmp:=tmp/xScale;
+ 'y': tmp:=tmp/yScale;
end;
except
exit;
@@ -2013,7 +2013,7 @@ begin
end;
end;
-function tKonkreteKoordinatenTransformation.initAbbildung(syntaxtest: boolean; s: string; xscale,yscale: extended; etf: tExprToFloat): boolean;
+function tKonkreteKoordinatenTransformation.initAbbildung(syntaxtest: boolean; s: string; xScale,yScale: extended; etf: tExprToFloat): boolean;
var
c,d: char;
i: longint;
@@ -2056,26 +2056,26 @@ begin
else if v='-' then tmp:=-1
else try
tmp:=etf(syntaxtest,v);
- if c='x' then tmp:=tmp/xscale
- else tmp:=tmp/yscale;
+ if c='x' then tmp:=tmp/xScale
+ else tmp:=tmp/yScale;
except
exit;
end;
if copy(t,pos('(',t)-3,3)='log' then begin
lnFak[c]:=tmp;
- if not findeLineareParameter(syntaxtest,' ',u,xscale,yscale,lnOff[c],lnInt[c,'x'],lnInt[c,'y'],true,etf) then exit;
+ if not findeLineareParameter(syntaxtest,' ',u,xScale,yScale,lnOff[c],lnInt[c,'x'],lnInt[c,'y'],true,etf) then exit;
end
else if copy(t,pos('(',t)-3,3)='exp' then begin
expFak[c]:=tmp;
tmp:=0;
- if not findeLineareParameter(syntaxtest,' ',u,xscale,yscale,tmp,expExp[c,'x'],expExp[c,'y'],true,etf) then exit;
+ if not findeLineareParameter(syntaxtest,' ',u,xScale,yScale,tmp,expExp[c,'x'],expExp[c,'y'],true,etf) then exit;
if tmp<>0 then exit;
end
else exit;
delete(t,i,pos(')',t)-i+1);
end;
if t<>'' then
- if not findeLineareParameter(syntaxtest,c,t,xscale,yscale,off[c],lin[c,'x'],lin[c,'y'],false,etf) then exit;
+ if not findeLineareParameter(syntaxtest,c,t,xScale,yScale,off[c],lin[c,'x'],lin[c,'y'],false,etf) then exit;
t:=s;
end;
result:=true;
@@ -2089,24 +2089,24 @@ begin
for c:='x' to 'y' do begin
result:=result+#13#10+c+' = ';
if off[c]<>0 then
- result:=result + floattostr(off[c]) + ' ';
+ result:=result + floatToStr(off[c]) + ' ';
for d:='x' to 'y' do
if lin[c,d]<>0 then
- result:=result + '+ ' + floattostr(lin[c,d]) + ' ' + d + ' ';
+ result:=result + '+ ' + floatToStr(lin[c,d]) + ' ' + d + ' ';
if lnFak[c]<>0 then begin
- result:=result + '+ ' + floattostr(lnFak[c])+' log ( ';
+ result:=result + '+ ' + floatToStr(lnFak[c])+' log ( ';
if lnOff[c]<>0 then
- result:=result + floattostr(lnoff[c]) + ' ';
+ result:=result + floatToStr(lnOff[c]) + ' ';
for d:='x' to 'y' do
if lnInt[c,d]<>0 then
- result:=result + '+ ' + floattostr(lnInt[c,d]) + ' ' + d + ' ';
+ result:=result + '+ ' + floatToStr(lnInt[c,d]) + ' ' + d + ' ';
result:=result + ') ';
end;
if expFak[c]<>0 then begin
- result:=result + '+ ' + floattostr(expFak[c])+' exp ( ';
+ result:=result + '+ ' + floatToStr(expFak[c])+' exp ( ';
for d:='x' to 'y' do
if expExp[c,d]<>0 then
- result:=result + '+ ' + floattostr(expExp[c,d]) + ' ' + d + ' ';
+ result:=result + '+ ' + floatToStr(expExp[c,d]) + ' ' + d + ' ';
result:=result + ') ';
end;
end;
@@ -2123,11 +2123,11 @@ begin
for d:='x' to 'y' do
result[c,d]:=-1;
for k:=0 to 1 do
- for i:=0 to (in_xs_ts['x']*(1-k)+in_xs_ts['y']*k)-1 do
+ for i:=0 to (inXSTS['x']*(1-k)+inXSTS['y']*k)-1 do
for j:=0 to 1 do begin
RandPkt:=transformiereKoordinaten(
- i*(1-k) + j*k*(in_xs_ts['x']-1),
- j*(1-k)*(in_xs_ts['y']-1) + i*k);
+ i*(1-k) + j*k*(inXSTS['x']-1),
+ j*(1-k)*(inXSTS['y']-1) + i*k);
for c:='x' to 'y' do
for d:='x' to 'y' do
if ((i=0) and (j=0)) or ((d='y') xor (result[c,d]>floor(RandPkt[c]) + byte(d='y'))) then
@@ -2142,7 +2142,7 @@ var
begin
gr:=zielausdehnung;
for c:='x' to 'y' do
- out_xs_ts[c]:=gr[c,'y']-gr[c,'x']+1;
+ outXSTS[c]:=gr[c,'y']-gr[c,'x']+1;
end;
// tLambdaZuOmegaTransformation ************************************************
@@ -2157,7 +2157,7 @@ end;
function tLambdaZuOmegaTransformation.verhaeltnisHorizontal: extended;
begin
if horizontal then
- result:=in_achsen['x','x']/(in_achsen['x','y']-in_achsen['x','x'])
+ result:=inAchsen['x','x']/(inAchsen['x','y']-inAchsen['x','x'])
else
result:=0;
end;
@@ -2165,7 +2165,7 @@ end;
function tLambdaZuOmegaTransformation.verhaeltnisVertikal: extended;
begin
if vertikal then
- result:=in_achsen['y','x']/(in_achsen['y','y']-in_achsen['y','x'])
+ result:=inAchsen['y','x']/(inAchsen['y','y']-inAchsen['y','x'])
else
result:=0;
end;
@@ -2183,19 +2183,19 @@ var
c: char;
begin
if horizontal then begin
- out_achsen['x','x']:=2*pi*299792458/in_achsen['x','y'];
- out_achsen['x','y']:=2*pi*299792458/in_achsen['x','x'];
+ outAchsen['x','x']:=2*pi*299792458/inAchsen['x','y'];
+ outAchsen['x','y']:=2*pi*299792458/inAchsen['x','x'];
end
else
for c:='x' to 'y' do
- out_achsen['x',c]:=in_achsen['x',c];
+ outAchsen['x',c]:=inAchsen['x',c];
if vertikal then begin
- out_achsen['y','x']:=2*pi*299792458/in_achsen['y','y'];
- out_achsen['y','y']:=2*pi*299792458/in_achsen['y','x'];
+ outAchsen['y','x']:=2*pi*299792458/inAchsen['y','y'];
+ outAchsen['y','y']:=2*pi*299792458/inAchsen['y','x'];
end
else
for c:='x' to 'y' do
- out_achsen['y',c]:=in_achsen['y',c];
+ outAchsen['y',c]:=inAchsen['y',c];
end;
function tLambdaZuOmegaTransformation.transformiereKoordinatenEinzeln(const p: tExtPoint): tExtPoint;
@@ -2206,7 +2206,7 @@ begin
if horizontal then begin
verh:=verhaeltnisHorizontal;
result['x']:=
- (1/(verh + p['x']/(in_xs_ts['x']-1)) - 1/verh) /
+ (1/(verh + p['x']/(inXSTS['x']-1)) - 1/verh) /
(1/(verh + 1) - 1/verh);
end
else
@@ -2214,7 +2214,7 @@ begin
if vertikal then begin
verh:=verhaeltnisVertikal;
result['y']:=
- (1/(verh + p['y']/(in_xs_ts['y']-1)) - 1/verh) /
+ (1/(verh + p['y']/(inXSTS['y']-1)) - 1/verh) /
(1/(verh + 1) - 1/verh);
end
else
@@ -2243,13 +2243,13 @@ begin
gr[c,d]:=0;
end;
-constructor tKoordinatenAusschnitt.create(vorg: tTransformation; xmin,xmax,tmin,tmax: longint);
+constructor tKoordinatenAusschnitt.create(vorg: tTransformation; xMin,xMax,tMin,tMax: longint);
begin
inherited create;
- gr['x','x']:=xmin;
- gr['x','y']:=xmax;
- gr['y','x']:=tmin;
- gr['y','y']:=tmax;
+ gr['x','x']:=xMin;
+ gr['x','y']:=xMax;
+ gr['y','x']:=tMin;
+ gr['y','y']:=tMax;
fuegeVorgaengerHinzu(vorg);
end;
@@ -2258,7 +2258,7 @@ var
c: char;
begin
for c:='x' to 'y' do
- out_xs_ts[c]:=max(0,min(in_xs_ts[c],gr[c,'y']+1)-gr[c,'x']);
+ outXSTS[c]:=max(0,min(inXSTS[c],gr[c,'y']+1)-gr[c,'x']);
end;
procedure tKoordinatenAusschnitt.aktualisiereAchsen;
@@ -2266,15 +2266,15 @@ var
c,d: char;
begin
for c:='x' to 'y' do
- if in_xs_ts[c]<=1 then begin
+ if inXSTS[c]<=1 then begin
for d:='x' to 'y' do
- out_achsen[c,d]:=in_achsen[c,d];
- if in_achsen[c,'x']<>in_achsen[c,'y'] then
- fehler('Nur eine Koordinate, aber '+floattostr(in_achsen[c,'x'])+' = '+c+'start <> '+c+'stop = '+floattostr(in_achsen[c,'y'])+'!');
+ outAchsen[c,d]:=inAchsen[c,d];
+ if inAchsen[c,'x']<>inAchsen[c,'y'] then
+ fehler('Nur eine Koordinate, aber '+floatToStr(inAchsen[c,'x'])+' = '+c+'start <> '+c+'stop = '+floatToStr(inAchsen[c,'y'])+'!');
end
else
for d:='x' to 'y' do
- out_achsen[c,d]:=in_achsen[c,'x'] + gr[c,d]/(in_xs_ts[c]-1)*(in_achsen[c,'y']-in_achsen[c,'x']);
+ outAchsen[c,d]:=inAchsen[c,'x'] + gr[c,d]/(inXSTS[c]-1)*(inAchsen[c,'y']-inAchsen[c,'x']);
end;
function tKoordinatenAusschnitt.transformiereKoordinatenEinzeln(const p: tExtPoint): tExtPoint;
@@ -2283,12 +2283,12 @@ var
begin
testeAuszerhalb(p);
for c:='x' to 'y' do
- result[c]:=max(0,min(out_xs_ts[c],p[c]-gr[c,'x']));
+ result[c]:=max(0,min(outXSTS[c],p[c]-gr[c,'x']));
end;
function tKoordinatenAusschnitt.dumpParams: string;
begin
- result:='Koordinatenausschnitt: '+inttostr(gr['x','x'])+'..'+inttostr(gr['x','y'])+' x '+inttostr(gr['y','x'])+'..'+inttostr(gr['y','y']);
+ result:='Koordinatenausschnitt: '+intToStr(gr['x','x'])+'..'+intToStr(gr['x','y'])+' x '+intToStr(gr['y','x'])+'..'+intToStr(gr['y','y']);
end;
// tFitTransformation **********************************************************
@@ -2302,7 +2302,7 @@ begin
_adStao['x']:=adStart; // Start und
_adStao['y']:=adStop; // Stopp in der "anderen Dimension"
if (_adLaenge=1) xor (_adStao['x']=_adStao['y']) then
- fehler('Die gefitteten Daten müssen genau dann eindimensional sein, wenn Start = Stopp ist. ('+inttostr(_adLaenge)+'-d vs. '+floattostr(_adStao['x'])+'..'+floattostr(_adStao['y'])+')');
+ fehler('Die gefitteten Daten müssen genau dann eindimensional sein, wenn Start = Stopp ist. ('+intToStr(_adLaenge)+'-d vs. '+floatToStr(_adStao['x'])+'..'+floatToStr(_adStao['y'])+')');
fuegeVorgaengerHinzu(daten);
end;
@@ -2311,7 +2311,7 @@ var
c: char;
begin
for c:='x' to 'y' do
- out_xs_ts[c]:=_adLaenge+(in_xs_ts[c]-_adLaenge)*byte(_senkrecht xor (c='y'));
+ outXSTS[c]:=_adLaenge+(inXSTS[c]-_adLaenge)*byte(_senkrecht xor (c='y'));
end;
procedure tFitTransformation.aktualisiereAchsen;
@@ -2319,9 +2319,9 @@ var
c: char;
begin
for c:='x' to 'y' do begin
- out_achsen[char(ord('x')+byte(_senkrecht)),c]:=
- in_achsen[char(ord('x')+byte(_senkrecht)),c];
- out_achsen[char(ord('y')-byte(_senkrecht)),c]:=
+ outAchsen[char(ord('x')+byte(_senkrecht)),c]:=
+ inAchsen[char(ord('x')+byte(_senkrecht)),c];
+ outAchsen[char(ord('y')-byte(_senkrecht)),c]:=
_adStao[c];
end;
end;
@@ -2357,7 +2357,7 @@ end;
function tAgglomeration.rNullposition: extended;
begin
if isNaN(_nullposition) then
- result:=in_achsen[char(ord('y')-byte(horizontal)),'x']
+ result:=inAchsen[char(ord('y')-byte(horizontal)),'x']
else
result:=_nullposition;
end;
@@ -2373,18 +2373,18 @@ var
i: longint;
begin
if length(vorgaenger)=0 then exit;
- in_achsen:=vorgaenger[0].achsen;
+ inAchsen:=vorgaenger[0].achsen;
for i:=1 to length(vorgaenger)-1 do
- if in_achsen <> vorgaenger[i].achsen then
+ if inAchsen <> vorgaenger[i].achsen then
fehler('Vorgänger haben verschiedene Achsen, was bei Agglomeration nicht geht!');
- in_xs_ts:=vorgaenger[0].xsteps_tsiz;
+ inXSTS:=vorgaenger[0].xStepsTSiz;
for i:=1 to length(vorgaenger)-1 do
- if in_xs_ts <> vorgaenger[i].xsteps_tsiz then
- fehler('Vorgänger haben verschiedene xsteps oder tsiz, was bei Agglomeration nicht geht!');
- in_wmia:=vorgaenger[0].wmia;
+ if inXSTS <> vorgaenger[i].xStepsTSiz then
+ fehler('Vorgänger haben verschiedene xSteps oder tSiz, was bei Agglomeration nicht geht!');
+ inWMia:=vorgaenger[0].wMia;
for i:=1 to length(vorgaenger)-1 do begin
- in_wmia['x']:=min(in_wmia['x'],vorgaenger[i].wmia['x']);
- in_wmia['y']:=max(in_wmia['y'],vorgaenger[i].wmia['y']);
+ inWMia['x']:=min(inWMia['x'],vorgaenger[i].wMia['x']);
+ inWMia['y']:=max(inWMia['y'],vorgaenger[i].wMia['y']);
end;
end;
@@ -2398,7 +2398,7 @@ var
c: char;
begin
for c:='x' to 'y' do
- out_xs_ts[c]:=in_xs_ts[c]*(1+(length(vorgaenger)-1)*byte(horizontal xor (c='y')));
+ outXSTS[c]:=inXSTS[c]*(1+(length(vorgaenger)-1)*byte(horizontal xor (c='y')));
end;
procedure tAgglomeration.aktualisiereAchsen;
@@ -2406,25 +2406,25 @@ var
c,d: char;
begin
for c:='x' to 'y' do
- if in_xs_ts[c]<=1 then begin // diese Dimension gibt es in der Quelle nicht
+ if inXSTS[c]<=1 then begin // diese Dimension gibt es in der Quelle nicht
if (horizontal xor (c='y')) and (schritt<0) then
fehler('Die Richtung einer Agglomeration ohne explizite Schrittweite kann nicht senkrecht zur Dimension eindimensionaler Daten sein!');
for d:='x' to 'y' do
- out_achsen[c,d]:=
- in_achsen[c,d] +
+ outAchsen[c,d]:=
+ inAchsen[c,d] +
byte(horizontal xor (c='y')) * ( // in Agglomerationsrichtung
- nullposition-in_achsen[c,'x'] + // Verschiebung durch explizite Nullposition
+ nullposition-inAchsen[c,'x'] + // Verschiebung durch explizite Nullposition
byte(d='y') * schritt*(length(vorgaenger)-1) // das Ende
);
- if in_achsen[c,'x']<>in_achsen[c,'y'] then
- fehler('Nur eine Koordinate, aber '+floattostr(in_achsen[c,'x'])+' = '+c+'start <> '+c+'stop = '+floattostr(in_achsen[c,'y'])+'!');
+ if inAchsen[c,'x']<>inAchsen[c,'y'] then
+ fehler('Nur eine Koordinate, aber '+floatToStr(inAchsen[c,'x'])+' = '+c+'start <> '+c+'stop = '+floatToStr(inAchsen[c,'y'])+'!');
end
else // diese Dimension gibt es in der Quelle
for d:='x' to 'y' do
- out_achsen[c,d]:=
- in_achsen[c,d] +
- (in_achsen[c,'y']-in_achsen[c,'x'])/
- (1+1/in_xs_ts[c]) *
+ outAchsen[c,d]:=
+ inAchsen[c,d] +
+ (inAchsen[c,'y']-inAchsen[c,'x'])/
+ (1+1/inXSTS[c]) *
(length(vorgaenger)-1) *
byte((horizontal xor (c='y')) and (d='y'));
end;
@@ -2439,9 +2439,9 @@ begin
i:=0;
c:=char(ord('y')-byte(l in [lOben,lUnten]));
if horizontal xor not (l in [lOben,lUnten]) then begin // aber nur, wenn der Wert auf einer Achse in Agglomerationsrichtung liegt
- x:=x+in_achsen[c,'x']-nullposition;
+ x:=x+inAchsen[c,'x']-nullposition;
if schritt<0 then // Schrittlänge berechnen
- s:=(vorgaenger[0].achsen[c,'y']-vorgaenger[0].achsen[c,'x'])*(1+1/vorgaenger[0].xsteps_tsiz[c])
+ s:=(vorgaenger[0].achsen[c,'y']-vorgaenger[0].achsen[c,'x'])*(1+1/vorgaenger[0].xStepsTSiz[c])
else
s:=schritt;
while (i<length(vorgaenger)) and (vorgaenger[i].achsen[c,'y']<x) do begin
@@ -2460,12 +2460,12 @@ end;
function tAgglomeration.dumpParams: string;
begin
- result:='Agglomeration: '+inttostr(length(vorgaenger))+'x ';
+ result:='Agglomeration: '+intToStr(length(vorgaenger))+'x ';
if horizontal then
result:=result+'horizont'
else
result:=result+'vertik';
- result:=result+'al um '+floattostr(schritt)+' versetzt';
+ result:=result+'al um '+floatToStr(schritt)+' versetzt';
end;
// tDiagonaleAgglomeration *****************************************************
@@ -2478,19 +2478,19 @@ end;
function tDiagonaleAgglomeration.datenRichtung: char;
begin
- if not (in_xs_ts['x']=1) xor (in_xs_ts['y']=1) then
- fehler('Diagonal zu agglomerierende Daten müssen eindimensional sein und nicht '+inttostr(in_xs_ts['x'])+'x'+inttostr(in_xs_ts['y'])+'!');
- result:=char(ord('x')+byte(in_xs_ts['y']<>1));
+ if not (inXSTS['x']=1) xor (inXSTS['y']=1) then
+ fehler('Diagonal zu agglomerierende Daten müssen eindimensional sein und nicht '+intToStr(inXSTS['x'])+'x'+intToStr(inXSTS['y'])+'!');
+ result:=char(ord('x')+byte(inXSTS['y']<>1));
end;
procedure tDiagonaleAgglomeration.holeInfosVonVorgaengern;
begin
if length(vorgaenger)=0 then exit;
- in_achsen:=vorgaenger[0].achsen;
+ inAchsen:=vorgaenger[0].achsen;
if length(vorgaenger)>1 then
fehler('Diagonale Agglomeration kann nur einen Vorgänger haben!');
- in_xs_ts:=vorgaenger[0].xsteps_tsiz;
- in_wmia:=vorgaenger[0].wmia;
+ inXSTS:=vorgaenger[0].xStepsTSiz;
+ inWMia:=vorgaenger[0].wMia;
end;
procedure tDiagonaleAgglomeration.aktualisiereXsTs;
@@ -2498,7 +2498,7 @@ var
c: char;
begin
for c:='x' to 'y' do
- out_xs_ts[c]:=in_xs_ts[datenRichtung];
+ outXSTS[c]:=inXSTS[datenRichtung];
end;
procedure tDiagonaleAgglomeration.aktualisiereAchsen;
@@ -2507,7 +2507,7 @@ var
begin
for c:='x' to 'y' do
for d:='x' to 'y' do
- out_achsen[c,d]:=in_achsen[datenRichtung,d];
+ outAchsen[c,d]:=inAchsen[datenRichtung,d];
end;
function tDiagonaleAgglomeration.wertZuPositionAufAchse(const l: tLage; x: extended): extended;
@@ -2528,12 +2528,12 @@ end;
constructor tWerteKnickTransformation.create;
begin
inherited create;
- setlength(parameter,0);
+ setLength(parameter,0);
end;
destructor tWerteKnickTransformation.destroy;
begin
- setlength(parameter,0);
+ setLength(parameter,0);
inherited destroy;
end;
@@ -2559,7 +2559,7 @@ var
begin
result:='Knick:';
for i:=0 to length(parameter) div 2 - 1 do
- result:=result + ' (' + floattostr(parameter[2*i])+';'+floattostr(parameter[2*i+1])+')';
+ result:=result + ' (' + floatToStr(parameter[2*i])+';'+floatToStr(parameter[2*i+1])+')';
end;
// tWerteLogTransformation *****************************************************
@@ -2577,7 +2577,7 @@ end;
function tWerteLogTransformation.dumpParams: string;
begin
- result:='Logarithmus: '+floattostr(logMin);
+ result:='Logarithmus: '+floatToStr(logMin);
end;
// tWerteLogAbsTransformation **************************************************
@@ -2595,7 +2595,7 @@ end;
function tWerteLogAbsTransformation.dumpParams: string;
begin
- result:='Betragslogarithmus: '+floattostr(logSkala);
+ result:='Betragslogarithmus: '+floatToStr(logSkala);
end;
// tWerteAbsTransformation *****************************************************
@@ -2615,7 +2615,7 @@ begin
result:='Betrag';
end;
-function liesTWerteTransformationen(st: boolean; s: string; f: tMyStringlist; etf: tExprToFloat; var tr: tTransformation): boolean;
+function liesTWerteTransformationen(sT: boolean; s: string; f: tMyStringList; etf: tExprToFloat; var tr: tTransformation): boolean;
var
i: longint;
tmp: tTransformation;
@@ -2626,7 +2626,7 @@ begin
if istDasBefehl('Knick',s,bekannteTransformationen,false) then begin
tmp:=tWerteKnickTransformation.create;
with (tmp as tWerteKnickTransformation) do begin
- setlength(parameter,2);
+ setLength(parameter,2);
parameter[0]:=0;
parameter[1]:=0;
repeat
@@ -2636,19 +2636,19 @@ begin
exit;
end;
if s='Ende' then break;
- setlength(parameter,length(parameter)+2);
+ setLength(parameter,length(parameter)+2);
parameter[length(parameter)-2]:=
- etf(st,erstesArgument(s,' '));
- if s='' then s:=inttostr(length(parameter) div 2 - 1);
+ etf(sT,erstesArgument(s,' '));
+ if s='' then s:=intToStr(length(parameter) div 2 - 1);
parameter[length(parameter)-1]:=
- etf(st,s);
+ etf(sT,s);
until false;
for i:=0 to length(parameter)-1 do
if odd(i) then
parameter[i]:=
parameter[i]/
(length(parameter) div 2);
- setlength(parameter,length(parameter)+2);
+ setLength(parameter,length(parameter)+2);
parameter[length(parameter)-2]:= 1;
parameter[length(parameter)-1]:= 1;
end;
@@ -2660,7 +2660,7 @@ begin
end;
if istDasBefehl('Log:',s,bekannteTransformationen,true) then begin
tmp:=tWerteLogTransformation.create;
- (tmp as tWerteLogTransformation).logMin:=etf(st,s);
+ (tmp as tWerteLogTransformation).logMin:=etf(sT,s);
result:=true;
tmp.fuegeVorgaengerHinzu(tr);
tr:=tmp;
@@ -2669,7 +2669,7 @@ begin
end;
if istDasBefehl('AbsLog:',s,bekannteTransformationen,true) then begin
tmp:=tWerteLogAbsTransformation.create;
- (tmp as tWerteLogAbsTransformation).logSkala:=etf(st,s);
+ (tmp as tWerteLogAbsTransformation).logSkala:=etf(sT,s);
result:=true;
tmp.fuegeVorgaengerHinzu(tr);
tr:=tmp;
diff --git a/werteunit.pas b/werteunit.pas
index 340d3a7..e8761e2 100644
--- a/werteunit.pas
+++ b/werteunit.pas
@@ -5,7 +5,7 @@ unit werteunit;
interface
uses
- Classes, SysUtils, typenunit, math, process, lowlevelunit, matheunit, fftunit;
+ classes, sysutils, typenunit, math, process, lowlevelunit, matheunit, fftunit;
type
// tLLWerte ********************************************************************
@@ -22,53 +22,55 @@ type
procedure sortiereMaxima(var maxima: tIntPointArray);
public
werte: array of wgen;
- params: tExtrainfos;
- constructor create(ps: tExtrainfos); overload;
- constructor create(original: pTLLWerteSingle; ps: tExtrainfos; xmin,xmax: longint); overload;
- constructor create(original: pTLLWerteDouble; ps: tExtrainfos; xmin,xmax: longint); overload;
- constructor create(original: pTLLWerteExtended; ps: tExtrainfos; xmin,xmax: longint); overload;
- procedure kopiereVon(st: boolean; original: pTLLWerteSingle); overload;
- procedure kopiereVon(st: boolean; original: pTLLWerteDouble); overload;
- procedure kopiereVon(st: boolean; original: pTLLWerteExtended); overload;
- procedure kopiereVon(st: boolean; original: pTLLWerteSingle; xmin,xmax: longint); overload;
- procedure kopiereVon(st: boolean; original: pTLLWerteDouble; xmin,xmax: longint); overload;
- procedure kopiereVon(st: boolean; original: pTLLWerteExtended; xmin,xmax: longint); overload;
- procedure kopiereVon(st: boolean; original: pTLLWerteSingle; xmin,xmax,tmin,tmax: longint); overload;
- procedure kopiereVon(st: boolean; original: pTLLWerteDouble; xmin,xmax,tmin,tmax: longint); overload;
- procedure kopiereVon(st: boolean; original: pTLLWerteExtended; xmin,xmax,tmin,tmax: longint); overload;
+ params: tExtraInfos;
+ constructor create(ps: tExtraInfos); overload;
+ constructor create(original: pTLLWerteSingle; ps: tExtraInfos; xMin,xMax: longint); overload;
+ constructor create(original: pTLLWerteDouble; ps: tExtraInfos; xMin,xMax: longint); overload;
+ constructor create(original: pTLLWerteExtended; ps: tExtraInfos; xMin,xMax: longint); overload;
+ procedure kopiereVon(sT: boolean; original: pTLLWerteSingle); overload;
+ procedure kopiereVon(sT: boolean; original: pTLLWerteDouble); overload;
+ procedure kopiereVon(sT: boolean; original: pTLLWerteExtended); overload;
+ procedure kopiereVon(sT: boolean; original: pTLLWerteSingle; xMin,xMax: longint); overload;
+ procedure kopiereVon(sT: boolean; original: pTLLWerteDouble; xMin,xMax: longint); overload;
+ procedure kopiereVon(sT: boolean; original: pTLLWerteExtended; xMin,xMax: longint); overload;
+ procedure kopiereVon(sT: boolean; original: pTLLWerteSingle; xMin,xMax,tMin,tMax: longint); overload;
+ procedure kopiereVon(sT: boolean; original: pTLLWerteDouble; xMin,xMax,tMin,tMax: longint); overload;
+ procedure kopiereVon(sT: boolean; original: pTLLWerteExtended; xMin,xMax,tMin,tMax: longint); overload;
procedure kopiereVonNach(original: pTLLWerteSingle; qxmin,qxmax,qtmin,qtmax,zxmin,ztmin: longint); overload;
procedure kopiereVonNach(original: pTLLWerteDouble; qxmin,qxmax,qtmin,qtmax,zxmin,ztmin: longint); overload;
procedure kopiereVonNach(original: pTLLWerteExtended; qxmin,qxmax,qtmin,qtmax,zxmin,ztmin: longint); overload;
- procedure kopiereVerzerrt(original: pTLLWerteSingle; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformation; va,na: longint); overload;
- procedure kopiereVerzerrt(original: pTLLWerteDouble; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformation; va,na: longint); overload;
- procedure kopiereVerzerrt(original: pTLLWerteExtended; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformation; va,na: longint); overload;
- procedure kopiereLOVerzerrt(original: pTLLWerteSingle; xmin,xmax,tmin,tmax: longint; verhHo,verhVe: extended); overload;
- procedure kopiereLOVerzerrt(original: pTLLWerteDouble; xmin,xmax,tmin,tmax: longint; verhHo,verhVe: extended); overload;
- procedure kopiereLOVerzerrt(original: pTLLWerteExtended; xmin,xmax,tmin,tmax: longint; verhHo,verhVe: extended); overload;
+ procedure kopiereVerzerrt(original: pTLLWerteSingle; zPs: tIntPointArray; zGs: tExtPointArray; zAs: tExtendedArray; xMin,xMax,tMin,tMax: longint; vB,nB: tTransformation; vA,nA: longint); overload;
+ procedure kopiereVerzerrt(original: pTLLWerteDouble; zPs: tIntPointArray; zGs: tExtPointArray; zAs: tExtendedArray; xMin,xMax,tMin,tMax: longint; vB,nB: tTransformation; vA,nA: longint); overload;
+ procedure kopiereVerzerrt(original: pTLLWerteExtended; zPs: tIntPointArray; zGs: tExtPointArray; zAs: tExtendedArray; xMin,xMax,tMin,tMax: longint; vB,nB: tTransformation; vA,nA: longint); overload;
+ procedure kopiereLOVerzerrt(original: pTLLWerteSingle; xMin,xMax,tMin,tMax: longint; verhHo,verhVe: extended); overload;
+ procedure kopiereLOVerzerrt(original: pTLLWerteDouble; xMin,xMax,tMin,tMax: longint; verhHo,verhVe: extended); overload;
+ procedure kopiereLOVerzerrt(original: pTLLWerteExtended; xMin,xMax,tMin,tMax: longint; verhHo,verhVe: extended); overload;
destructor destroy; override;
function liesDateien(dateien: tGenerischeInputDateiInfoArray): boolean;
function fft(senkrecht,invers: boolean; algo: tFFTAlgorithmus; fen: tFenster; hg: extended; out pvFehler: extended): boolean; overload; inline;
function fft(smin,smax: longint; senkrecht,invers: boolean; algo: tFFTAlgorithmus; fen: tFenster; hg: extended; out pvFehler: extended): boolean; overload;
procedure spiegle; overload;
- procedure spiegle(tmin,tmax: longint); overload;
- procedure fft2dNachbearbeitungA(nb: tFFTDatenordnung);
- procedure fft2dNachbearbeitungB(xmin,xmax: longint; nb: tFFTDatenordnung);
+ procedure spiegle(tMin,tMax: longint); overload;
+ procedure fft2dNachbearbeitungA(nB: tFFTDatenordnung);
+ procedure fft2dNachbearbeitungB(xMin,xMax: longint; nB: tFFTDatenordnung);
+ procedure fft2dNachbearbeitungVerdoppeln(nB: tFFTDatenordnung);
procedure schreibeWert(var f: textfile; x,y: longint); overload;
procedure schreibeWert(var f: textfile; x,y,wert: extended); overload;
procedure schreibeWertIntegriert(var f: textfile; i: longint; hor: boolean);
procedure erzeugeBinning(senkrecht,linien: boolean; x0,dx: extended; s: string);
- procedure holeRam; inline; overload;
- procedure holeRam(ausgaben: byte); inline; overload;
- procedure holeRam(ausgaben: byte; gemaeszTXMinMax: boolean); inline; overload;
- procedure gibMinMaxDichten(out wMi,wMa: extended; xmin,xmax,tmin,tmax: longint);
- function zuPixelWerten(whoehe,wbreite,xpmi,xmi,tmi: longint; xz,yz: extended; pPWerte: pTExtendedArray; pPAnzahlen: pTLongintArray): boolean;
- function findeSchwellwerte(xmi,xma,tmi,tma: longint; Schw: extended): tExtPointArray;
- procedure integriereSingle(qu: pTLLWerteSingle; xmi,xma,tmi,tma,xof,tof: longint; richtung: tIntegrationsRichtung);
- procedure integriereDouble(qu: pTLLWerteDouble; xmi,xma,tmi,tma,xof,tof: longint; richtung: tIntegrationsRichtung);
- procedure integriereExtended(qu: pTLLWerteDouble; xmi,xma,tmi,tma,xof,tof: longint; richtung: tIntegrationsRichtung);
+ procedure holeRAM; inline; overload;
+ procedure holeRAM(ausgaben: byte); inline; overload;
+ procedure holeRAM(ausgaben: byte; gemaeszTXMinMax: boolean); inline; overload;
+ procedure gibMinMaxDichten(out wMi,wMa: extended; xMin,xMax,tMin,tMax: longint);
+ function zuPixelWerten(wHoehe,wBreite,xPMi,xMi,tMi: longint; xZ,yZ: extended; pPWerte: pTExtendedArray; pPAnzahlen: pTLongintArray): boolean;
+ function findeSchwellwerte(xMi,xMa,tMi,tMa: longint; Schw: extended): tExtPointArray;
+ procedure integriereSingle(qu: pTLLWerteSingle; xMi,xMa,tMi,tMa,xOf,tOf: longint; richtung: tIntegrationsRichtung);
+ procedure integriereDouble(qu: pTLLWerteDouble; xMi,xMa,tMi,tMa,xOf,tOf: longint; richtung: tIntegrationsRichtung);
+ procedure integriereExtended(qu: pTLLWerteDouble; xMi,xMa,tMi,tMa,xOf,tOf: longint; richtung: tIntegrationsRichtung);
procedure gauszFit(amplituden,breiten,positionen,ueberlappe,hintergruende: pTLLWerteExtended; von,bis: longint; senkrecht: boolean; fensterBreite,maxBreite,maxVerschiebung: extended; positionsMitten: tExtendedArray);
function ermittleHintergrund: extended;
- procedure filtereHoheFrequenzen(betraege: tLLWerte; xFak,yFak: extended);
+ procedure kantenFilter(betraege: tLLWerte; xFak,yFak: extended; filterTyp: tKantenFilterTyp); overload;
+ procedure kantenFilter(betraege: tLLWerte; xFak,yFak: extended; filterTyp: tKantenFilterTyp; einseitig: boolean; out maxPos: tIntPoint); overload;
procedure fenstereWerte(xMi,xMa,tMi,tMa: int64; xFen,tFen: tFenster; hg: extended);
end;
tLLWerteSingle = specialize tLLWerte<single>;
@@ -77,7 +79,7 @@ type
// andere Typen ****************************************************************
tWavelet = class(tObject)
freq,tfwhm,pvFehler: extended;
- hlen: longint;
+ hLen: longint;
typ: tWaveletTyp;
werte: tLLWerteDouble;
mitFFT: boolean;
@@ -104,16 +106,16 @@ var
tmp: tIntPoint;
i,li,re,cnt: int64;
begin
- setlength(vons,1);
+ setLength(vons,1);
vons[0]:=0;
- setlength(biss,1);
+ setLength(biss,1);
biss[0]:=length(maxima)-1;
- setlength(mins,1);
- setlength(maxs,1);
+ setLength(mins,1);
+ setLength(maxs,1);
mins[0]:=0;
maxs[0]:=0;
for i:=vons[0] to biss[0] do begin
- wert:=werte[maxima[i]['x']+maxima[i]['y']*params.xsteps];
+ wert:=werte[maxima[i]['x']+maxima[i]['y']*params.xSteps];
if (i=vons[0]) or (wert>maxs[0]) then
maxs[0]:=wert;
if (i=vons[0]) or (wert<mins[0]) then
@@ -131,10 +133,10 @@ begin
end;
if cnt>=length(vons) then begin
- setlength(vons,cnt+100);
- setlength(biss,cnt+100);
- setlength(mins,cnt+100);
- setlength(maxs,cnt+100);
+ setLength(vons,cnt+100);
+ setLength(biss,cnt+100);
+ setLength(mins,cnt+100);
+ setLength(maxs,cnt+100);
end;
pivot:=sqrt(maxs[cnt-1]*mins[cnt-1]);//(maxs[cnt-1]+mins[cnt-1])/2;
@@ -145,14 +147,14 @@ begin
mins[cnt-1]:=maxs[cnt-1];
while li<=re do begin
- wertLi:=werte[maxima[li]['x']+maxima[li]['y']*params.xsteps];
+ wertLi:=werte[maxima[li]['x']+maxima[li]['y']*params.xSteps];
if wertLi>=pivot then begin
if wertLi<mins[cnt-1] then
mins[cnt-1]:=wertLi;
inc(li);
continue;
end;
- wertRe:=werte[maxima[re]['x']+maxima[re]['y']*params.xsteps];
+ wertRe:=werte[maxima[re]['x']+maxima[re]['y']*params.xSteps];
if wertRe<=pivot then begin
if wertRe>maxs[cnt] then
maxs[cnt]:=wertRe;
@@ -180,139 +182,139 @@ begin
end;
end;
-constructor tLLWerte.create(ps: tExtrainfos);
+constructor tLLWerte.create(ps: tExtraInfos);
begin
inherited create;
params:=ps;
- setlength(werte,0);
+ setLength(werte,0);
end;
-constructor tLLWerte.create(original: pTLLWerteSingle; ps: tExtrainfos; xmin,xmax: longint);
+constructor tLLWerte.create(original: pTLLWerteSingle; ps: tExtraInfos; xMin,xMax: longint);
begin
inherited create;
params:=ps;
- kopiereVon(false,original,xmin,xmax);
+ kopiereVon(false,original,xMin,xMax);
end;
-constructor tLLWerte.create(original: pTLLWerteDouble; ps: tExtrainfos; xmin,xmax: longint);
+constructor tLLWerte.create(original: pTLLWerteDouble; ps: tExtraInfos; xMin,xMax: longint);
begin
inherited create;
params:=ps;
- kopiereVon(false,original,xmin,xmax);
+ kopiereVon(false,original,xMin,xMax);
end;
-constructor tLLWerte.create(original: pTLLWerteExtended; ps: tExtrainfos; xmin,xmax: longint);
+constructor tLLWerte.create(original: pTLLWerteExtended; ps: tExtraInfos; xMin,xMax: longint);
begin
inherited create;
params:=ps;
- kopiereVon(false,original,xmin,xmax);
+ kopiereVon(false,original,xMin,xMax);
end;
-procedure tLLWerte.kopiereVon(st: boolean; original: pTLLWerteSingle);
+procedure tLLWerte.kopiereVon(sT: boolean; original: pTLLWerteSingle);
begin
- kopiereVon(st,original,0,original^.params.xsteps-1);
+ kopiereVon(sT,original,0,original^.params.xSteps-1);
end;
-procedure tLLWerte.kopiereVon(st: boolean; original: pTLLWerteDouble);
+procedure tLLWerte.kopiereVon(sT: boolean; original: pTLLWerteDouble);
begin
- kopiereVon(st,original,0,original^.params.xsteps-1);
+ kopiereVon(sT,original,0,original^.params.xSteps-1);
end;
-procedure tLLWerte.kopiereVon(st: boolean; original: pTLLWerteExtended);
+procedure tLLWerte.kopiereVon(sT: boolean; original: pTLLWerteExtended);
begin
- kopiereVon(st,original,0,original^.params.xsteps-1);
+ kopiereVon(sT,original,0,original^.params.xSteps-1);
end;
-procedure tLLWerte.kopiereVon(st: boolean; original: pTLLWerteSingle; xmin,xmax: longint);
+procedure tLLWerte.kopiereVon(sT: boolean; original: pTLLWerteSingle; xMin,xMax: longint);
begin
- kopiereVon(st,original,xmin,xmax,0,original^.params.tsiz-1);
+ kopiereVon(sT,original,xMin,xMax,0,original^.params.tSiz-1);
end;
-procedure tLLWerte.kopiereVon(st: boolean; original: pTLLWerteDouble; xmin,xmax: longint);
+procedure tLLWerte.kopiereVon(sT: boolean; original: pTLLWerteDouble; xMin,xMax: longint);
begin
- kopiereVon(st,original,xmin,xmax,0,original^.params.tsiz-1);
+ kopiereVon(sT,original,xMin,xMax,0,original^.params.tSiz-1);
end;
-procedure tLLWerte.kopiereVon(st: boolean; original: pTLLWerteExtended; xmin,xmax: longint);
+procedure tLLWerte.kopiereVon(sT: boolean; original: pTLLWerteExtended; xMin,xMax: longint);
begin
- kopiereVon(st,original,xmin,xmax,0,original^.params.tsiz-1);
+ kopiereVon(sT,original,xMin,xMax,0,original^.params.tSiz-1);
end;
-procedure tLLWerte.kopiereVon(st: boolean; original: pTLLWerteSingle; xmin,xmax,tmin,tmax: longint);
+procedure tLLWerte.kopiereVon(sT: boolean; original: pTLLWerteSingle; xMin,xMax,tMin,tMax: longint);
var
i,j: longint;
begin
inherited create;
- tmax:=min(tmax,original^.params.tsiz-1);
- tmin:=max(tmin,0);
- params.tsiz:=tmax+1-tmin;
- xmax:=min(xmax,original^.params.xsteps-1);
- xmin:=max(xmin,0);
- params.xsteps:=xmax+1-xmin;
+ tMax:=min(tMax,original^.params.tSiz-1);
+ tMin:=max(tMin,0);
+ params.tSiz:=tMax+1-tMin;
+ xMax:=min(xMax,original^.params.xSteps-1);
+ xMin:=max(xMin,0);
+ params.xSteps:=xMax+1-xMin;
zerstoereTransformationWennObsolet(params.transformationen);
- params.transformationen:=tKoordinatenAusschnitt.create(original^.params.transformationen,xmin,xmax,tmin,tmax);
+ params.transformationen:=tKoordinatenAusschnitt.create(original^.params.transformationen,xMin,xMax,tMin,tMax);
params.maxW:=0;
params.minW:=0;
params.np:=original^.params.np;
params.beta:=original^.params.beta;
params.refreshKnownValues;
- if not st then begin
- holeRam(0);
- for i:=xmin to xmax do
- for j:=tmin to tmax do
- werte[i-xmin+(j-tmin)*params.xsteps]:=original^.werte[i+j*original^.params.xsteps];
+ if not sT then begin
+ holeRAM(0);
+ for i:=xMin to xMax do
+ for j:=tMin to tMax do
+ werte[i-xMin+(j-tMin)*params.xSteps]:=original^.werte[i+j*original^.params.xSteps];
end;
end;
-procedure tLLWerte.kopiereVon(st: boolean; original: pTLLWerteDouble; xmin,xmax,tmin,tmax: longint);
+procedure tLLWerte.kopiereVon(sT: boolean; original: pTLLWerteDouble; xMin,xMax,tMin,tMax: longint);
var
i,j: longint;
begin
inherited create;
- tmax:=min(tmax,original^.params.tsiz-1);
- tmin:=max(tmin,0);
- params.tsiz:=tmax+1-tmin;
- xmax:=min(xmax,original^.params.xsteps-1);
- xmin:=max(xmin,0);
- params.xsteps:=xmax+1-xmin;
+ tMax:=min(tMax,original^.params.tSiz-1);
+ tMin:=max(tMin,0);
+ params.tSiz:=tMax+1-tMin;
+ xMax:=min(xMax,original^.params.xSteps-1);
+ xMin:=max(xMin,0);
+ params.xSteps:=xMax+1-xMin;
zerstoereTransformationWennObsolet(params.transformationen);
- params.transformationen:=tKoordinatenAusschnitt.create(original^.params.transformationen,xmin,xmax,tmin,tmax);
+ params.transformationen:=tKoordinatenAusschnitt.create(original^.params.transformationen,xMin,xMax,tMin,tMax);
params.maxW:=0;
params.minW:=0;
params.np:=original^.params.np;
params.beta:=original^.params.beta;
params.refreshKnownValues;
- if not st then begin
- holeRam(0);
- for i:=xmin to xmax do
- for j:=tmin to tmax do
- werte[i-xmin+(j-tmin)*params.xsteps]:=original^.werte[i+j*original^.params.xsteps];
+ if not sT then begin
+ holeRAM(0);
+ for i:=xMin to xMax do
+ for j:=tMin to tMax do
+ werte[i-xMin+(j-tMin)*params.xSteps]:=original^.werte[i+j*original^.params.xSteps];
end;
end;
-procedure tLLWerte.kopiereVon(st: boolean; original: pTLLWerteExtended; xmin,xmax,tmin,tmax: longint);
+procedure tLLWerte.kopiereVon(sT: boolean; original: pTLLWerteExtended; xMin,xMax,tMin,tMax: longint);
var
i,j: longint;
begin
inherited create;
- tmax:=min(tmax,original^.params.tsiz-1);
- tmin:=max(tmin,0);
- params.tsiz:=tmax+1-tmin;
- xmax:=min(xmax,original^.params.xsteps-1);
- xmin:=max(xmin,0);
- params.xsteps:=xmax+1-xmin;
+ tMax:=min(tMax,original^.params.tSiz-1);
+ tMin:=max(tMin,0);
+ params.tSiz:=tMax+1-tMin;
+ xMax:=min(xMax,original^.params.xSteps-1);
+ xMin:=max(xMin,0);
+ params.xSteps:=xMax+1-xMin;
zerstoereTransformationWennObsolet(params.transformationen);
- params.transformationen:=tKoordinatenAusschnitt.create(original^.params.transformationen,xmin,xmax,tmin,tmax);
+ params.transformationen:=tKoordinatenAusschnitt.create(original^.params.transformationen,xMin,xMax,tMin,tMax);
params.maxW:=0;
params.minW:=0;
params.np:=original^.params.np;
params.beta:=original^.params.beta;
params.refreshKnownValues;
- if not st then begin
- holeRam(0);
- for i:=xmin to xmax do
- for j:=tmin to tmax do
- werte[i-xmin+(j-tmin)*params.xsteps]:=original^.werte[i+j*original^.params.xsteps];
+ if not sT then begin
+ holeRAM(0);
+ for i:=xMin to xMax do
+ for j:=tMin to tMax do
+ werte[i-xMin+(j-tMin)*params.xSteps]:=original^.werte[i+j*original^.params.xSteps];
end;
end;
@@ -323,8 +325,8 @@ begin
inherited create;
for i:=qxmin to qxmax do
for j:=qtmin to qtmax do
- werte[i-qxmin+zxmin + (j-qtmin+ztmin)*params.xsteps]:=
- original^.werte[i+j*original^.params.xsteps];
+ werte[i-qxmin+zxmin + (j-qtmin+ztmin)*params.xSteps]:=
+ original^.werte[i+j*original^.params.xSteps];
end;
procedure tLLWerte.kopiereVonNach(original: pTLLWerteDouble; qxmin,qxmax,qtmin,qtmax,zxmin,ztmin: longint);
@@ -334,8 +336,8 @@ begin
inherited create;
for i:=qxmin to qxmax do
for j:=qtmin to qtmax do
- werte[i-qxmin+zxmin + (j-qtmin+ztmin)*params.xsteps]:=
- original^.werte[i+j*original^.params.xsteps];
+ werte[i-qxmin+zxmin + (j-qtmin+ztmin)*params.xSteps]:=
+ original^.werte[i+j*original^.params.xSteps];
end;
procedure tLLWerte.kopiereVonNach(original: pTLLWerteExtended; qxmin,qxmax,qtmin,qtmax,zxmin,ztmin: longint);
@@ -345,125 +347,125 @@ begin
inherited create;
for i:=qxmin to qxmax do
for j:=qtmin to qtmax do
- werte[i-qxmin+zxmin + (j-qtmin+ztmin)*params.xsteps]:=
- original^.werte[i+j*original^.params.xsteps];
+ werte[i-qxmin+zxmin + (j-qtmin+ztmin)*params.xSteps]:=
+ original^.werte[i+j*original^.params.xSteps];
end;
-procedure tLLWerte.kopiereVerzerrt(original: pTLLWerteSingle; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformation; va,na: longint);
+procedure tLLWerte.kopiereVerzerrt(original: pTLLWerteSingle; zPs: tIntPointArray; zGs: tExtPointArray; zAs: tExtendedArray; xMin,xMax,tMin,tMax: longint; vB,nB: tTransformation; vA,nA: longint);
var
i,j,k: longint;
tmp: extended;
begin
- for i:=tmin to tmax do
- for j:=xmin to xmax do
- werte[j+i*params.xsteps]:=0;
- for i:=0 to length(ZPs)-1 do
+ for i:=tMin to tMax do
+ for j:=xMin to xMax do
+ werte[j+i*params.xSteps]:=0;
+ for i:=0 to length(zPs)-1 do
for j:=0 to 1 do
for k:=0 to 1 do
- if (ZPs[i]['x']+j>=xmin) and (ZPs[i]['x']+j<=xmax) and
- (ZPs[i]['y']+k>=tmin) and (ZPs[i]['y']+k<=tmax) then begin
+ if (zPs[i]['x']+j>=xMin) and (zPs[i]['x']+j<=xMax) and
+ (zPs[i]['y']+k>=tMin) and (zPs[i]['y']+k<=tMax) then begin
tmp:=original^.werte[i];
- if (va>0) or (na>0) then
+ if (vA>0) or (nA>0) then
tmp:=(tmp-original^.params.minW)/(original^.params.maxW-original^.params.minW);
- if va>0 then
- vb.transformiereWert(tmp,va-1);
- tmp:=tmp * (ZGs[i]['x'] * (2*j-1) + 1-j) * (ZGs[i]['y'] * (2*k-1) + 1-k);
- werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params.xsteps]:=
- werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params.xsteps] +
+ if vA>0 then
+ vB.transformiereWert(tmp,vA-1);
+ tmp:=tmp * (zGs[i]['x'] * (2*j-1) + 1-j) * (zGs[i]['y'] * (2*k-1) + 1-k);
+ werte[zPs[i]['x']+j + (zPs[i]['y']+k)*params.xSteps]:=
+ werte[zPs[i]['x']+j + (zPs[i]['y']+k)*params.xSteps] +
tmp;
end;
- for i:=tmin to tmax do
- for j:=xmin to xmax do begin
- tmp:=werte[j + i*params.xsteps] / ZAs[j + i*params.xsteps];
- if na>0 then
- tmp:=nb.transformiereWert(tmp,na-1);
- werte[j + i*params.xsteps]:=tmp;
+ for i:=tMin to tMax do
+ for j:=xMin to xMax do begin
+ tmp:=werte[j + i*params.xSteps] / zAs[j + i*params.xSteps];
+ if nA>0 then
+ tmp:=nB.transformiereWert(tmp,nA-1);
+ werte[j + i*params.xSteps]:=tmp;
end;
end;
-procedure tLLWerte.kopiereVerzerrt(original: pTLLWerteDouble; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformation; va,na: longint);
+procedure tLLWerte.kopiereVerzerrt(original: pTLLWerteDouble; zPs: tIntPointArray; zGs: tExtPointArray; zAs: tExtendedArray; xMin,xMax,tMin,tMax: longint; vB,nB: tTransformation; vA,nA: longint);
var
i,j,k: longint;
tmp: extended;
begin
- for i:=tmin to tmax do
- for j:=xmin to xmax do
- werte[j+i*params.xsteps]:=0;
- for i:=0 to length(ZPs)-1 do
+ for i:=tMin to tMax do
+ for j:=xMin to xMax do
+ werte[j+i*params.xSteps]:=0;
+ for i:=0 to length(zPs)-1 do
for j:=0 to 1 do
for k:=0 to 1 do
- if (ZPs[i]['x']+j>=xmin) and (ZPs[i]['x']+j<=xmax) and
- (ZPs[i]['y']+k>=tmin) and (ZPs[i]['y']+k<=tmax) then begin
+ if (zPs[i]['x']+j>=xMin) and (zPs[i]['x']+j<=xMax) and
+ (zPs[i]['y']+k>=tMin) and (zPs[i]['y']+k<=tMax) then begin
tmp:=original^.werte[i];
- if (va>0) or (na>0) then
+ if (vA>0) or (nA>0) then
tmp:=(tmp-original^.params.minW)/(original^.params.maxW-original^.params.minW);
- if va>0 then
- vb.transformiereWert(tmp,va-1);
- tmp:=tmp * (ZGs[i]['x'] * (2*j-1) + 1-j) * (ZGs[i]['y'] * (2*k-1) + 1-k);
- werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params.xsteps]:=
- werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params.xsteps] +
+ if vA>0 then
+ vB.transformiereWert(tmp,vA-1);
+ tmp:=tmp * (zGs[i]['x'] * (2*j-1) + 1-j) * (zGs[i]['y'] * (2*k-1) + 1-k);
+ werte[zPs[i]['x']+j + (zPs[i]['y']+k)*params.xSteps]:=
+ werte[zPs[i]['x']+j + (zPs[i]['y']+k)*params.xSteps] +
tmp;
end;
- for i:=tmin to tmax do
- for j:=xmin to xmax do begin
- tmp:=werte[j + i*params.xsteps] / ZAs[j + i*params.xsteps];
- if na>0 then
- tmp:=nb.transformiereWert(tmp,na-1);
- werte[j + i*params.xsteps]:=tmp;
+ for i:=tMin to tMax do
+ for j:=xMin to xMax do begin
+ tmp:=werte[j + i*params.xSteps] / zAs[j + i*params.xSteps];
+ if nA>0 then
+ tmp:=nB.transformiereWert(tmp,nA-1);
+ werte[j + i*params.xSteps]:=tmp;
end;
end;
-procedure tLLWerte.kopiereVerzerrt(original: pTLLWerteExtended; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformation; va,na: longint);
+procedure tLLWerte.kopiereVerzerrt(original: pTLLWerteExtended; zPs: tIntPointArray; zGs: tExtPointArray; zAs: tExtendedArray; xMin,xMax,tMin,tMax: longint; vB,nB: tTransformation; vA,nA: longint);
var
i,j,k: longint;
tmp: extended;
begin
- for i:=tmin to tmax do
- for j:=xmin to xmax do
- werte[j+i*params.xsteps]:=0;
- for i:=0 to length(ZPs)-1 do
+ for i:=tMin to tMax do
+ for j:=xMin to xMax do
+ werte[j+i*params.xSteps]:=0;
+ for i:=0 to length(zPs)-1 do
for j:=0 to 1 do
for k:=0 to 1 do
- if (ZPs[i]['x']+j>=xmin) and (ZPs[i]['x']+j<=xmax) and
- (ZPs[i]['y']+k>=tmin) and (ZPs[i]['y']+k<=tmax) then begin
+ if (zPs[i]['x']+j>=xMin) and (zPs[i]['x']+j<=xMax) and
+ (zPs[i]['y']+k>=tMin) and (zPs[i]['y']+k<=tMax) then begin
tmp:=original^.werte[i];
- if (va>0) or (na>0) then
+ if (vA>0) or (nA>0) then
tmp:=(tmp-original^.params.minW)/(original^.params.maxW-original^.params.minW);
- if va>0 then
- vb.transformiereWert(tmp,va-1);
- tmp:=tmp * (ZGs[i]['x'] * (2*j-1) + 1-j) * (ZGs[i]['y'] * (2*k-1) + 1-k);
- werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params.xsteps]:=
- werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params.xsteps] +
+ if vA>0 then
+ vB.transformiereWert(tmp,vA-1);
+ tmp:=tmp * (zGs[i]['x'] * (2*j-1) + 1-j) * (zGs[i]['y'] * (2*k-1) + 1-k);
+ werte[zPs[i]['x']+j + (zPs[i]['y']+k)*params.xSteps]:=
+ werte[zPs[i]['x']+j + (zPs[i]['y']+k)*params.xSteps] +
tmp;
end;
- for i:=tmin to tmax do
- for j:=xmin to xmax do begin
- tmp:=werte[j + i*params.xsteps] / ZAs[j + i*params.xsteps];
- if na>0 then
- tmp:=nb.transformiereWert(tmp,na-1);
- werte[j + i*params.xsteps]:=tmp;
+ for i:=tMin to tMax do
+ for j:=xMin to xMax do begin
+ tmp:=werte[j + i*params.xSteps] / zAs[j + i*params.xSteps];
+ if nA>0 then
+ tmp:=nB.transformiereWert(tmp,nA-1);
+ werte[j + i*params.xSteps]:=tmp;
end;
end;
-procedure tLLWerte.kopiereLOVerzerrt(original: pTLLWerteSingle; xmin,xmax,tmin,tmax: longint; verhHo,verhVe: extended); overload;
+procedure tLLWerte.kopiereLOVerzerrt(original: pTLLWerteSingle; xMin,xMax,tMin,tMax: longint; verhHo,verhVe: extended); overload;
var
i,j,hV,hB,vV,vB,h,v: int64;
begin
- writeln(xmin,' .. ',xmax,' x ',tmin,' .. ',tmax);
- for i:=tmin to tmax do begin
+ writeln(xMin,' .. ',xMax,' x ',tMin,' .. ',tMax);
+ for i:=tMin to tMax do begin
if verhVe>0 then begin
vV:=max(
0,
round(
- (params.tsiz-1-i+0.5)/
- (1 + (i+0.5)/verhVe/(params.tsiz-1))
+ (params.tSiz-1-i+0.5)/
+ (1 + (i+0.5)/verhVe/(params.tSiz-1))
)
);
vB:=min(
- params.tsiz-1,
+ params.tSiz-1,
round(
- (params.tsiz-1-i+0.5)/
- (1 + (i-0.5)/verhVe/(params.tsiz-1))
+ (params.tSiz-1-i+0.5)/
+ (1 + (i-0.5)/verhVe/(params.tSiz-1))
)
);
end
@@ -471,20 +473,20 @@ begin
vV:=i;
vB:=i;
end;
- for j:=xmin to xmax do begin
+ for j:=xMin to xMax do begin
if verhHo>0 then begin
hV:=max(
0,
round(
- (params.xsteps-1-(j+0.5))/
- (1 + (j+0.5)/verhHo/(params.xsteps-1))
+ (params.xSteps-1-(j+0.5))/
+ (1 + (j+0.5)/verhHo/(params.xSteps-1))
)
);
hB:=min(
- params.xsteps-1,
+ params.xSteps-1,
round(
- (params.xsteps-1-(j-0.5))/
- (1 + (j-0.5)/verhHo/(params.xsteps-1))
+ (params.xSteps-1-(j-0.5))/
+ (1 + (j-0.5)/verhHo/(params.xSteps-1))
)
);
end
@@ -492,38 +494,38 @@ begin
hV:=j;
hB:=j;
end;
- werte[j+i*params.xsteps]:=0;
+ werte[j+i*params.xSteps]:=0;
for h:=hV to hB do
for v:=vV to vB do
- werte[j+i*params.xsteps]:=
- werte[j+i*params.xsteps]+
- original^.werte[h+v*params.xsteps];
+ werte[j+i*params.xSteps]:=
+ werte[j+i*params.xSteps]+
+ original^.werte[h+v*params.xSteps];
if (hB>=hV) and (vB>=vV) then
- werte[j+i*params.xsteps]:=
- werte[j+i*params.xsteps] / (hB+1-hV) / (vB+1-vV);
+ werte[j+i*params.xSteps]:=
+ werte[j+i*params.xSteps] / (hB+1-hV) / (vB+1-vV);
end;
end;
end;
-procedure tLLWerte.kopiereLOVerzerrt(original: pTLLWerteDouble; xmin,xmax,tmin,tmax: longint; verhHo,verhVe: extended); overload;
+procedure tLLWerte.kopiereLOVerzerrt(original: pTLLWerteDouble; xMin,xMax,tMin,tMax: longint; verhHo,verhVe: extended); overload;
var
i,j,hV,hB,vV,vB,h,v: int64;
begin
- writeln(xmin,' .. ',xmax,' x ',tmin,' .. ',tmax);
- for i:=tmin to tmax do begin
+ writeln(xMin,' .. ',xMax,' x ',tMin,' .. ',tMax);
+ for i:=tMin to tMax do begin
if verhVe>0 then begin
vV:=max(
0,
round(
- (params.tsiz-1-i+0.5)/
- (1 + (i+0.5)/verhVe/(params.tsiz-1))
+ (params.tSiz-1-i+0.5)/
+ (1 + (i+0.5)/verhVe/(params.tSiz-1))
)
);
vB:=min(
- params.tsiz-1,
+ params.tSiz-1,
round(
- (params.tsiz-1-i+0.5)/
- (1 + (i-0.5)/verhVe/(params.tsiz-1))
+ (params.tSiz-1-i+0.5)/
+ (1 + (i-0.5)/verhVe/(params.tSiz-1))
)
);
end
@@ -531,20 +533,20 @@ begin
vV:=i;
vB:=i;
end;
- for j:=xmin to xmax do begin
+ for j:=xMin to xMax do begin
if verhHo>0 then begin
hV:=max(
0,
round(
- (params.xsteps-1-(j+0.5))/
- (1 + (j+0.5)/verhHo/(params.xsteps-1))
+ (params.xSteps-1-(j+0.5))/
+ (1 + (j+0.5)/verhHo/(params.xSteps-1))
)
);
hB:=min(
- params.xsteps-1,
+ params.xSteps-1,
round(
- (params.xsteps-1-(j-0.5))/
- (1 + (j-0.5)/verhHo/(params.xsteps-1))
+ (params.xSteps-1-(j-0.5))/
+ (1 + (j-0.5)/verhHo/(params.xSteps-1))
)
);
end
@@ -552,38 +554,38 @@ begin
hV:=j;
hB:=j;
end;
- werte[j+i*params.xsteps]:=0;
+ werte[j+i*params.xSteps]:=0;
for h:=hV to hB do
for v:=vV to vB do
- werte[j+i*params.xsteps]:=
- werte[j+i*params.xsteps]+
- original^.werte[h+v*params.xsteps];
+ werte[j+i*params.xSteps]:=
+ werte[j+i*params.xSteps]+
+ original^.werte[h+v*params.xSteps];
if (hB>=hV) and (vB>=vV) then
- werte[j+i*params.xsteps]:=
- werte[j+i*params.xsteps] / (hB+1-hV) / (vB+1-vV);
+ werte[j+i*params.xSteps]:=
+ werte[j+i*params.xSteps] / (hB+1-hV) / (vB+1-vV);
end;
end;
end;
-procedure tLLWerte.kopiereLOVerzerrt(original: pTLLWerteExtended; xmin,xmax,tmin,tmax: longint; verhHo,verhVe: extended); overload;
+procedure tLLWerte.kopiereLOVerzerrt(original: pTLLWerteExtended; xMin,xMax,tMin,tMax: longint; verhHo,verhVe: extended); overload;
var
i,j,hV,hB,vV,vB,h,v: int64;
begin
- writeln(xmin,' .. ',xmax,' x ',tmin,' .. ',tmax);
- for i:=tmin to tmax do begin
+ writeln(xMin,' .. ',xMax,' x ',tMin,' .. ',tMax);
+ for i:=tMin to tMax do begin
if verhVe>0 then begin
vV:=max(
0,
round(
- (params.tsiz-1-i+0.5)/
- (1 + (i+0.5)/verhVe/(params.tsiz-1))
+ (params.tSiz-1-i+0.5)/
+ (1 + (i+0.5)/verhVe/(params.tSiz-1))
)
);
vB:=min(
- params.tsiz-1,
+ params.tSiz-1,
round(
- (params.tsiz-1-i+0.5)/
- (1 + (i-0.5)/verhVe/(params.tsiz-1))
+ (params.tSiz-1-i+0.5)/
+ (1 + (i-0.5)/verhVe/(params.tSiz-1))
)
);
end
@@ -591,20 +593,20 @@ begin
vV:=i;
vB:=i;
end;
- for j:=xmin to xmax do begin
+ for j:=xMin to xMax do begin
if verhHo>0 then begin
hV:=max(
0,
round(
- (params.xsteps-1-(j+0.5))/
- (1 + (j+0.5)/verhHo/(params.xsteps-1))
+ (params.xSteps-1-(j+0.5))/
+ (1 + (j+0.5)/verhHo/(params.xSteps-1))
)
);
hB:=min(
- params.xsteps-1,
+ params.xSteps-1,
round(
- (params.xsteps-1-(j-0.5))/
- (1 + (j-0.5)/verhHo/(params.xsteps-1))
+ (params.xSteps-1-(j-0.5))/
+ (1 + (j-0.5)/verhHo/(params.xSteps-1))
)
);
end
@@ -612,50 +614,50 @@ begin
hV:=j;
hB:=j;
end;
- werte[j+i*params.xsteps]:=0;
+ werte[j+i*params.xSteps]:=0;
for h:=hV to hB do
for v:=vV to vB do
- werte[j+i*params.xsteps]:=
- werte[j+i*params.xsteps]+
- original^.werte[h+v*params.xsteps];
+ werte[j+i*params.xSteps]:=
+ werte[j+i*params.xSteps]+
+ original^.werte[h+v*params.xSteps];
if (hB>=hV) and (vB>=vV) then
- werte[j+i*params.xsteps]:=
- werte[j+i*params.xsteps] / (hB+1-hV) / (vB+1-vV);
+ werte[j+i*params.xSteps]:=
+ werte[j+i*params.xSteps] / (hB+1-hV) / (vB+1-vV);
end;
end;
end;
destructor tLLWerte.destroy;
begin
- setlength(werte,0);
+ setLength(werte,0);
inherited destroy;
end;
function tLLWerte.liesDateien(dateien: tGenerischeInputDateiInfoArray): boolean;
var
- i,j,k,l,tmpi,etsiz,spAnz,br: longint;
+ i,j,k,l,tmpI,etsiz,spAnz,br: longint;
f: file;
- tmps: single;
- tmpd: double;
- tmpe,Zeit: extended;
- sa: tSingleArray;
+ tmpS: single;
+ tmpD: double;
+ tmpE,Zeit: extended;
+ sA: tSingleArray;
da: tDoubleArray;
ea: tExtendedArray;
- ipp: tProcess;
+ iPP: tProcess;
buf: tByteArray;
etwasGelesen: boolean;
s: string;
begin
result:=false;
gibAus('... Dateien einlesen ...',1);
- zeit:=now;
- tmpi:=0;
- tmps:=0;
- tmpd:=0;
+ Zeit:=now;
+ tmpI:=0;
+ tmpS:=0;
+ tmpD:=0;
etsiz:=0;
spAnz:=-1;
for i:=0 to length(dateien)-1 do begin
- gibAus(' '+dateien[i].Name,1);
+ gibAus(' '+dateien[i].name,1);
etwasGelesen:=false;
if dateien[i] is tPipeInputDateiInfo then begin
if ((dateien[i] as tPipeInputDateiInfo).bytesPerSample<>4) or
@@ -663,42 +665,42 @@ begin
gibAus('Ich kann nur vier Bytes mit einem mal als Integer interpretiert aus einer Pipe einlesen!',3);
exit;
end;
- tmpe:=power(2,-31);
- ipp:=tProcess.create(nil);
- ipp.Options:=ipp.Options + [poUsePipes];
- ipp.Executable:=(dateien[i] as tPipeInputDateiInfo).Executable;
- ipp.Parameters.Text:=(dateien[i] as tPipeInputDateiInfo).ParametersText;
- ipp.execute;
- setlength(buf,0);
+ tmpE:=power(2,-31);
+ iPP:=tProcess.create(nil);
+ iPP.options:=iPP.options + [poUsePipes];
+ iPP.executable:=(dateien[i] as tPipeInputDateiInfo).executable;
+ iPP.parameters.text:=(dateien[i] as tPipeInputDateiInfo).parametersText;
+ iPP.execute;
+ setLength(buf,0);
br:=0;
- while ipp.running or (ipp.Output.NumBytesAvailable>0) do begin
- if ipp.Output.NumBytesAvailable > 0 then begin
- if br+ipp.Output.NumBytesAvailable>=length(buf) then
- setlength(buf,br+ipp.Output.NumBytesAvailable+65536*1024);
- tmpi:=ipp.Output.Read(buf[br],min(ipp.Output.NumBytesAvailable,length(buf)-br));
- if ((br+tmpi) shr 24) > (br shr 24) then gibAus(inttostr(br+tmpi)+' von '+inttostr(dateien[i].tsiz*dateien[i].xsteps*4)+' Bytes bisher gelesen ('+floattostrtrunc((br+tmpi)/(dateien[i].tsiz*dateien[i].xsteps*4)*100,2,true)+'%).',1);
- br:=br+tmpi;
+ while iPP.running or (iPP.output.numBytesAvailable>0) do begin
+ if iPP.output.numBytesAvailable > 0 then begin
+ if br+iPP.output.numBytesAvailable>=length(buf) then
+ setLength(buf,br+iPP.output.numBytesAvailable+65536*1024);
+ tmpI:=iPP.output.read(buf[br],min(iPP.output.numBytesAvailable,length(buf)-br));
+ if ((br+tmpI) shr 24) > (br shr 24) then gibAus(intToStr(br+tmpI)+' von '+intToStr(dateien[i].tSiz*dateien[i].xSteps*4)+' Bytes bisher gelesen ('+floattostrtrunc((br+tmpI)/(dateien[i].tSiz*dateien[i].xSteps*4)*100,2,true)+'%).',1);
+ br:=br+tmpI;
end
else
sleep(10);
end;
- ipp.free;
- gibAus('insgesamt '+inttostr(br div 1024 div 1024)+' MB gelesen.',1);
- setlength(buf,br);
- if dateien[i].tsiz*dateien[i].xsteps*4>length(buf) then begin
- gibAus('Ich habe '+inttostr(length(buf))+' Bytes aus der Pipe gelesen, anstelle von wenigstens '+inttostr(dateien[i].tsiz*dateien[i].xsteps*4)+', wie erwartet!',3);
- setlength(buf,0);
+ iPP.free;
+ gibAus('insgesamt '+intToStr(br div 1024 div 1024)+' MB gelesen.',1);
+ setLength(buf,br);
+ if dateien[i].tSiz*dateien[i].xSteps*4>length(buf) then begin
+ gibAus('Ich habe '+intToStr(length(buf))+' Bytes aus der Pipe gelesen, anstelle von wenigstens '+intToStr(dateien[i].tSiz*dateien[i].xSteps*4)+', wie erwartet!',3);
+ setLength(buf,0);
exit;
end;
- tmpi:=length(buf)-4*dateien[i].tsiz*dateien[i].xsteps; // der Offset des ersten Daten-Wortes
- for j:=dateien[i].tmin to dateien[i].tmax do
- for k:=dateien[i].xmin to dateien[i].xmax do
- werte[dateien[i].t0abs+ k-dateien[i].xmin + (j-dateien[i].tmin)*(dateien[i].xmax-dateien[i].xmin+1)]:=
- int32((((((buf[tmpi+3+4*(k+j*dateien[i].xsteps)] shl 8) or
- buf[tmpi+2+4*(k+j*dateien[i].xsteps)]) shl 8) or
- buf[tmpi+1+4*(k+j*dateien[i].xsteps)]) shl 8) or
- buf[tmpi+4*(k+j*dateien[i].xsteps)]) * tmpe;
- setlength(buf,0);
+ tmpI:=length(buf)-4*dateien[i].tSiz*dateien[i].xSteps; // der Offset des ersten Daten-Wortes
+ for j:=dateien[i].tMin to dateien[i].tMax do
+ for k:=dateien[i].xMin to dateien[i].xMax do
+ werte[dateien[i].t0Abs+ k-dateien[i].xMin + (j-dateien[i].tMin)*(dateien[i].xMax-dateien[i].xMin+1)]:=
+ int32((((((buf[tmpI+3+4*(k+j*dateien[i].xSteps)] shl 8) or
+ buf[tmpI+2+4*(k+j*dateien[i].xSteps)]) shl 8) or
+ buf[tmpI+1+4*(k+j*dateien[i].xSteps)]) shl 8) or
+ buf[tmpI+4*(k+j*dateien[i].xSteps)]) * tmpE;
+ setLength(buf,0);
if etwasGelesen then begin
gibAus('Ich habe diese Runde schon Daten gelesen!',3);
exit;
@@ -707,77 +709,77 @@ begin
end;
if (dateien[i] is tSpaceTimeInputDateiInfo) or
(dateien[i] is tTraceInputDateiInfo) then begin
- assign(f,dateien[i].Name);
+ assign(f,dateien[i].name);
reset(f,1);
- blockread(f,tmpi,sizeof(integer));
- dec(tmpi);
- if tmpi-round(params.tstart/dateien[i].groeszenFaktor)<>i then begin
- gibAus('Datei '''+dateien[i].Name+''' kommt nicht an '+inttostr(i)+'-ter Stelle, wie sie sollte, sondern an '+inttostr(tmpi-round(params.tstart/dateien[i].groeszenFaktor))+'-ter.',3);
+ blockread(f,tmpI,sizeOf(integer));
+ dec(tmpI);
+ if tmpI-round(params.tStart/dateien[i].groeszenFaktor)<>i then begin
+ gibAus('Datei '''+dateien[i].name+''' kommt nicht an '+intToStr(i)+'-ter Stelle, wie sie sollte, sondern an '+intToStr(tmpI-round(params.tStart/dateien[i].groeszenFaktor))+'-ter.',3);
close(f);
exit;
end;
if dateien[i] is tTraceInputDateiInfo then begin
- blockread(f,tmpi,sizeof(integer)); // #Traces
- spAnz:=tmpi;
+ blockread(f,tmpI,sizeOf(integer)); // #Traces
+ spAnz:=tmpI;
end;
- blockread(f,etsiz,sizeof(integer));
+ blockread(f,etsiz,sizeOf(integer));
if dateien[i] is tSpaceTimeInputDateiInfo then begin
for j:=0 to etsiz-1 do begin
- case Dateien[i].Genauigkeit of
+ case dateien[i].genauigkeit of
gSingle: begin
- blockread(f,tmps,sizeof(single)); // xstart
- tmpe:=tmps;
+ blockread(f,tmpS,sizeOf(single)); // xStart
+ tmpE:=tmpS;
end;
gDouble: begin
- blockread(f,tmpd,sizeof(double)); // xstart
- tmpe:=tmpd;
+ blockread(f,tmpD,sizeOf(double)); // xStart
+ tmpE:=tmpD;
end;
gExtended:
- blockread(f,tmpe,sizeof(extended)); // xstart
+ blockread(f,tmpE,sizeOf(extended)); // xStart
end{of Case};
- tmpe:=tmpe*dateien[i].groeszenFaktor;
- if j=0 then params.transformationen.xstart:=tmpe;
- if tmpe<>params.transformationen.xstart then begin
- gibAus('Falscher linker Rand in '''+dateien[i].Name+''' im Schritt '+inttostr(j)+', nämlich '+myfloattostr(tmpe)+' statt '+myfloattostr(params.transformationen.xstart)+'!',3);
+ tmpE:=tmpE*dateien[i].groeszenFaktor;
+ if j=0 then params.transformationen.xStart:=tmpE;
+ if tmpE<>params.transformationen.xStart then begin
+ gibAus('Falscher linker Rand in '''+dateien[i].name+''' im Schritt '+intToStr(j)+', nämlich '+myFloatToStr(tmpE)+' statt '+myFloatToStr(params.transformationen.xStart)+'!',3);
close(f);
exit;
end;
- case Dateien[i].Genauigkeit of
+ case dateien[i].genauigkeit of
gSingle: begin
- blockread(f,tmps,sizeof(single)); // xstop
- tmpe:=tmps;
+ blockread(f,tmpS,sizeOf(single)); // xStop
+ tmpE:=tmpS;
end;
gDouble: begin
- blockread(f,tmpd,sizeof(double)); // xstop
- tmpe:=tmpd;
+ blockread(f,tmpD,sizeOf(double)); // xStop
+ tmpE:=tmpD;
end;
gExtended:
- blockread(f,tmpe,sizeof(extended)); // xstop
+ blockread(f,tmpE,sizeOf(extended)); // xStop
end{of Case};
- tmpe:=tmpe*dateien[i].groeszenFaktor;
- if j=0 then params.transformationen.xstop:=tmpe;
- if tmpe<>params.transformationen.xstop then begin
- gibAus('Falscher rechter Rand in '''+dateien[i].Name+''' im Schritt '+inttostr(j)+', nämlich '+myfloattostr(tmpe)+' statt '+myfloattostr(params.transformationen.xstop)+'!',3);
+ tmpE:=tmpE*dateien[i].groeszenFaktor;
+ if j=0 then params.transformationen.xStop:=tmpE;
+ if tmpE<>params.transformationen.xStop then begin
+ gibAus('Falscher rechter Rand in '''+dateien[i].name+''' im Schritt '+intToStr(j)+', nämlich '+myFloatToStr(tmpE)+' statt '+myFloatToStr(params.transformationen.xStop)+'!',3);
close(f);
exit;
end;
- blockread(f,tmpi,sizeof(integer)); // xsteps
- if tmpi<>params.xsteps then begin
- gibAus('Falsche Anzahl an x-Schritten in '''+dateien[i].Name+''' im Schritt '+inttostr(j)+', nämlich '+inttostr(tmpi)+' statt '+myfloattostr(params.xsteps)+'!',3);
+ blockread(f,tmpI,sizeOf(integer)); // xSteps
+ if tmpI<>params.xSteps then begin
+ gibAus('Falsche Anzahl an x-Schritten in '''+dateien[i].name+''' im Schritt '+intToStr(j)+', nämlich '+intToStr(tmpI)+' statt '+myFloatToStr(params.xSteps)+'!',3);
close(f);
exit;
end;
- if sizeof(wgen) = wertGroesze(Dateien[i].Genauigkeit) then
- blockread(f,werte[(j+Dateien[i].t0abs)*params.xsteps],params.xsteps*sizeof(wgen))
+ if sizeOf(wgen) = wertGroesze(dateien[i].genauigkeit) then
+ blockread(f,werte[(j+dateien[i].t0Abs)*params.xSteps],params.xSteps*sizeOf(wgen))
else begin
- setlength(sa,params.xsteps);
- blockread(f,sa[0],params.xsteps*sizeof(single));
- for k:=0 to params.xsteps-1 do
- werte[(j+Dateien[i].t0abs)*params.xsteps+k]:=sa[k];
+ setLength(sA,params.xSteps);
+ blockread(f,sA[0],params.xSteps*sizeOf(single));
+ for k:=0 to params.xSteps-1 do
+ werte[(j+dateien[i].t0Abs)*params.xSteps+k]:=sA[k];
end;
if power(dateien[i].gamma,3)/sqr(dateien[i].groeszenFaktor)<>1 then // gamma^3 als Skalierungsfaktor für Dichten ?
- for k:=0 to params.xsteps-1 do
- werte[(j+Dateien[i].t0abs)*params.xsteps+k]:=werte[(j+Dateien[i].t0abs)*params.xsteps+k]*power(dateien[i].gamma,3)/sqr(dateien[i].groeszenFaktor);
+ for k:=0 to params.xSteps-1 do
+ werte[(j+dateien[i].t0Abs)*params.xSteps+k]:=werte[(j+dateien[i].t0Abs)*params.xSteps+k]*power(dateien[i].gamma,3)/sqr(dateien[i].groeszenFaktor);
end;
if etwasGelesen then begin
gibAus('Ich habe diese Runde schon Daten gelesen!',3);
@@ -786,37 +788,37 @@ begin
etwasGelesen:=true;
end;
if dateien[i] is tTraceInputDateiInfo then begin
- case Dateien[i].Genauigkeit of
+ case dateien[i].genauigkeit of
gSingle: begin
- setlength(sa,etsiz);
- setlength(da,0);
- setlength(ea,0);
+ setLength(sA,etsiz);
+ setLength(da,0);
+ setLength(ea,0);
end;
gDouble: begin
- setlength(sa,0);
- setlength(da,etsiz);
- setlength(ea,0);
+ setLength(sA,0);
+ setLength(da,etsiz);
+ setLength(ea,0);
end;
gExtended: begin
- setlength(sa,0);
- setlength(da,0);
- setlength(ea,etsiz);
+ setLength(sA,0);
+ setLength(da,0);
+ setLength(ea,etsiz);
end;
end{of case};
for j:=0 to spAnz-1 do
- case Dateien[i].Genauigkeit of
+ case dateien[i].genauigkeit of
gSingle: begin
- blockread(f,tmps,sizeof(single)); // x
- if j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer then begin
- params.transformationen.xstop:=tmps;
- params.transformationen.xstart:=params.xstop;
+ blockread(f,tmpS,sizeOf(single)); // x
+ if j=(dateien[i] as tTraceInputDateiInfo).spurNummer then begin
+ params.transformationen.xStop:=tmpS;
+ params.transformationen.xStart:=params.xStop;
end;
- for k:=0 to length(FeldgroeszenNamen)-1 do begin
- blockread(f,sa[0],sizeof(single)*length(sa));
- if (j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer) and
- (k=(Dateien[i] as tTraceInputDateiInfo).Feldnummer) then begin
- for l:=0 to length(sa)-1 do
- werte[l+Dateien[i].t0abs]:=sa[l]*sqr(dateien[i].gamma)/sqr(dateien[i].groeszenFaktor);
+ for k:=0 to length(feldGroeszenNamen)-1 do begin
+ blockread(f,sA[0],sizeOf(single)*length(sA));
+ if (j=(dateien[i] as tTraceInputDateiInfo).spurNummer) and
+ (k=(dateien[i] as tTraceInputDateiInfo).feldNummer) then begin
+ for l:=0 to length(sA)-1 do
+ werte[l+dateien[i].t0Abs]:=sA[l]*sqr(dateien[i].gamma)/sqr(dateien[i].groeszenFaktor);
if etwasGelesen then begin
gibAus('Ich habe diese Runde schon Daten gelesen!',3);
exit;
@@ -826,17 +828,17 @@ begin
end;
end;
gDouble: begin
- blockread(f,tmpd,sizeof(double)); // x
- if j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer then begin
- params.transformationen.xstop:=tmpd;
- params.transformationen.xstart:=params.xstop;
+ blockread(f,tmpD,sizeOf(double)); // x
+ if j=(dateien[i] as tTraceInputDateiInfo).spurNummer then begin
+ params.transformationen.xStop:=tmpD;
+ params.transformationen.xStart:=params.xStop;
end;
- for k:=0 to length(FeldgroeszenNamen)-1 do begin
- blockread(f,da[0],sizeof(double)*length(da));
- if (j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer) and
- (k=(Dateien[i] as tTraceInputDateiInfo).Feldnummer) then begin
+ for k:=0 to length(feldGroeszenNamen)-1 do begin
+ blockread(f,da[0],sizeOf(double)*length(da));
+ if (j=(dateien[i] as tTraceInputDateiInfo).spurNummer) and
+ (k=(dateien[i] as tTraceInputDateiInfo).feldNummer) then begin
for l:=0 to length(da)-1 do
- werte[l+dateien[i].t0abs]:=da[l]*sqr(dateien[i].gamma)/sqr(dateien[i].groeszenFaktor);
+ werte[l+dateien[i].t0Abs]:=da[l]*sqr(dateien[i].gamma)/sqr(dateien[i].groeszenFaktor);
if etwasGelesen then begin
gibAus('Ich habe diese Runde schon Daten gelesen!',3);
exit;
@@ -846,17 +848,17 @@ begin
end;
end;
gExtended: begin
- blockread(f,tmpe,sizeof(extended)); // x
- if j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer then begin
- params.transformationen.xstop:=tmpe;
- params.transformationen.xstart:=params.xstop;
+ blockread(f,tmpE,sizeOf(extended)); // x
+ if j=(dateien[i] as tTraceInputDateiInfo).spurNummer then begin
+ params.transformationen.xStop:=tmpE;
+ params.transformationen.xStart:=params.xStop;
end;
- for k:=0 to length(FeldgroeszenNamen)-1 do begin
- blockread(f,ea[0],sizeof(extended)*length(ea));
- if (j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer) and
- (k=(Dateien[i] as tTraceInputDateiInfo).Feldnummer) then begin
+ for k:=0 to length(feldGroeszenNamen)-1 do begin
+ blockread(f,ea[0],sizeOf(extended)*length(ea));
+ if (j=(dateien[i] as tTraceInputDateiInfo).spurNummer) and
+ (k=(dateien[i] as tTraceInputDateiInfo).feldNummer) then begin
for l:=0 to length(ea)-1 do
- werte[l+dateien[i].t0abs]:=ea[l]*sqr(dateien[i].gamma)/sqr(dateien[i].groeszenFaktor);
+ werte[l+dateien[i].t0Abs]:=ea[l]*sqr(dateien[i].gamma)/sqr(dateien[i].groeszenFaktor);
if etwasGelesen then begin
gibAus('Ich habe diese Runde schon Daten gelesen!',3);
exit;
@@ -868,7 +870,7 @@ begin
end{of Case};
end;
if not eof(f) then begin
- gibAus('Zu viele Daten in '''+dateien[i].Name+'''!',3);
+ gibAus('Zu viele Daten in '''+dateien[i].name+'''!',3);
close(f);
exit;
end;
@@ -880,50 +882,50 @@ begin
close(f);
exit;
end;
- assign(f,dateien[i].Name);
+ assign(f,dateien[i].name);
reset(f,1);
- seek(f,filepos(f)
- + 4*wertGroesze(dateien[i].genauigkeit) // xstart,xstop,tstart,tstop
- + 2*sizeof(longint)); // xsteps,tsiz
- blockread(f,werte[0],params.xsteps*params.tsiz*wertGroesze(dateien[i].genauigkeit));
+ seek(f,filePos(f)
+ + 4*wertGroesze(dateien[i].genauigkeit) // xStart,xStop,tStart,tStop
+ + 2*sizeOf(longint)); // xSteps,tSiz
+ blockread(f,werte[0],params.xSteps*params.tSiz*wertGroesze(dateien[i].genauigkeit));
close(f);
etwasGelesen:=true;
end;
if dateien[i] is tSergeyInputDateiInfo then begin
- etsiz:=Dateien[i].tsiz;
+ etsiz:=dateien[i].tSiz;
- setlength(buf,sizeof(extended)*anzSergeyFelder);
- tmpi:=wertGroesze(Dateien[i].Genauigkeit);
+ setLength(buf,sizeOf(extended)*anzSergeyFelder);
+ tmpI:=wertGroesze(dateien[i].genauigkeit);
- assign(f,dateien[i].Name+'traces/traces.dat');
+ assign(f,dateien[i].name+'traces/traces.dat');
reset(f,1);
- setlength(buf,tmpi*anzSergeyFelder);
+ setLength(buf,tmpI*anzSergeyFelder);
for j:=0 to etsiz-1 do begin
- if (Dateien[i] as tSergeyInputDateiInfo).Feldnummer>0 then
- blockread(f,buf[0],(Dateien[i] as tSergeyInputDateiInfo).Feldnummer*tmpi);
+ if (dateien[i] as tSergeyInputDateiInfo).feldNummer>0 then
+ blockread(f,buf[0],(dateien[i] as tSergeyInputDateiInfo).feldNummer*tmpI);
case dateien[i].genauigkeit of
gSingle: begin
- blockread(f,tmps,tmpi);
- werte[j]:=tmps;
+ blockread(f,tmpS,tmpI);
+ werte[j]:=tmpS;
end;
gDouble: begin
- blockread(f,tmpd,tmpi);
- werte[j]:=tmpd;
+ blockread(f,tmpD,tmpI);
+ werte[j]:=tmpD;
end;
gExtended: begin
- blockread(f,tmpe,tmpi);
- werte[j]:=tmpe;
+ blockread(f,tmpE,tmpI);
+ werte[j]:=tmpE;
end;
end{of Case};
- if (Dateien[i] as tSergeyInputDateiInfo).Feldnummer<anzSergeyFelder-1 then
- blockread(f,buf[0],(anzSergeyFelder-1-(Dateien[i] as tSergeyInputDateiInfo).Feldnummer)*tmpi);
+ if (dateien[i] as tSergeyInputDateiInfo).feldNummer<anzSergeyFelder-1 then
+ blockread(f,buf[0],(anzSergeyFelder-1-(dateien[i] as tSergeyInputDateiInfo).feldNummer)*tmpI);
end;
- setlength(buf,0);
+ setLength(buf,0);
if not eof(f) then begin
- gibAus('Zu viele Daten in '''+dateien[i].Name+'traces/traces.dat''!',3);
+ gibAus('Zu viele Daten in '''+dateien[i].name+'traces/traces.dat''!',3);
close(f);
exit;
end;
@@ -931,29 +933,29 @@ begin
etwasGelesen:=true;
end;
if dateien[i] is tAndorInputDateiInfo then begin
- etsiz:=dateien[i].tsiz;
+ etsiz:=dateien[i].tSiz;
- assign(f,dateien[i].Name);
+ assign(f,dateien[i].name);
reset(f,1);
seek(f,(dateien[i] as tAndorInputDateiInfo).datenStart);
- tmpi:=wertGroesze(dateien[i].genauigkeit);
- if tmpi = sizeOf(wgen) then
- blockread(f,werte[0],dateien[i].xsteps*dateien[i].tsiz*tmpi)
+ tmpI:=wertGroesze(dateien[i].genauigkeit);
+ if tmpI = sizeOf(wgen) then
+ blockread(f,werte[0],dateien[i].xSteps*dateien[i].tSiz*tmpI)
else case dateien[i].genauigkeit of
gSingle:
- for j:=0 to dateien[i].xsteps*dateien[i].tsiz-1 do begin
- blockread(f,tmps,tmpi);
- werte[j]:=tmps;
+ for j:=0 to dateien[i].xSteps*dateien[i].tSiz-1 do begin
+ blockread(f,tmpS,tmpI);
+ werte[j]:=tmpS;
end;
gDouble:
- for j:=0 to dateien[i].xsteps*dateien[i].tsiz-1 do begin
- blockread(f,tmpd,tmpi);
- werte[j]:=tmpd;
+ for j:=0 to dateien[i].xSteps*dateien[i].tSiz-1 do begin
+ blockread(f,tmpD,tmpI);
+ werte[j]:=tmpD;
end;
gExtended:
- for j:=0 to dateien[i].xsteps*dateien[i].tsiz-1 do begin
- blockread(f,tmpe,tmpi);
- werte[j]:=tmpe;
+ for j:=0 to dateien[i].xSteps*dateien[i].tSiz-1 do begin
+ blockread(f,tmpE,tmpI);
+ werte[j]:=tmpE;
end;
end{of case};
try
@@ -962,8 +964,8 @@ begin
s:='falsch';
end;
if s<>'' then begin
- gibAus('Syntax-Fehler in '''+dateien[i].Name+''': vmtl. zu viele/wenige Daten.',3);
- closefile(f);
+ gibAus('Syntax-Fehler in '''+dateien[i].name+''': vmtl. zu viele/wenige Daten.',3);
+ closeFile(f);
exit;
end;
close(f);
@@ -979,25 +981,25 @@ begin
result:=true;
end;
-procedure tLLWerte.gibMinMaxDichten(out wMi,wMa: extended; xmin,xmax,tmin,tmax: longint);
+procedure tLLWerte.gibMinMaxDichten(out wMi,wMa: extended; xMin,xMax,tMin,tMax: longint);
var
i,j: longint;
begin
- wMi:=werte[xmin+tmin*params.xsteps];
- wMa:=Werte[xmin+tmin*params.xsteps];
- for i:=xmin to xmax do
- for j:=tmin to tmax do begin
- wMi:=min(wMi,werte[i+j*params.xsteps]);
- wMa:=max(wMa,werte[i+j*params.xsteps]);
+ wMi:=werte[xMin+tMin*params.xSteps];
+ wMa:=werte[xMin+tMin*params.xSteps];
+ for i:=xMin to xMax do
+ for j:=tMin to tMax do begin
+ wMi:=min(wMi,werte[i+j*params.xSteps]);
+ wMa:=max(wMa,werte[i+j*params.xSteps]);
end;
end;
function tLLWerte.fft(senkrecht,invers: boolean; algo: tFFTAlgorithmus; fen: tFenster; hg: extended; out pvFehler: extended): boolean;
begin
if senkrecht then
- result:=fft(0,params.xsteps-1,senkrecht,invers,algo,fen,hg,pvFehler)
+ result:=fft(0,params.xSteps-1,senkrecht,invers,algo,fen,hg,pvFehler)
else
- result:=fft(0,params.tsiz-1,senkrecht,invers,algo,fen,hg,pvFehler);
+ result:=fft(0,params.tSiz-1,senkrecht,invers,algo,fen,hg,pvFehler);
end;
function tLLWerte.fft(smin,smax: longint; senkrecht,invers: boolean; algo: tFFTAlgorithmus; fen: tFenster; hg: extended; out pvFehler: extended): boolean;
@@ -1008,28 +1010,28 @@ var
begin
result:=false;
if senkrecht then begin
- pmax:=params.tsiz-1;
- pstep:=params.xsteps;
+ pmax:=params.tSiz-1;
+ pstep:=params.xSteps;
sstep:=1;
end
else begin
- pmax:=params.xsteps-1;
+ pmax:=params.xSteps-1;
pstep:=1;
- sstep:=params.xsteps;
+ sstep:=params.xSteps;
end;
if assigned(fen) and fen.aktiv then begin
if invers then
gibAus('fft: Warnung, hier wird bei einer inversen FFT gefenstert - soll das so sein?',1);
offset:=byte(not invers)*hg;
- if length(fen.Werte)<>pmax+1 then begin
- gibAus('Die Breite des FFT-Fensters ('+inttostr(length(fen.Werte))+') ist nicht gleich der Breite der Werte ('+inttostr(pmax+1)+')!',1);
+ if length(fen.werte)<>pmax+1 then begin
+ gibAus('Die Breite des FFT-Fensters ('+intToStr(length(fen.werte))+') ist nicht gleich der Breite der Werte ('+intToStr(pmax+1)+')!',1);
exit;
end;
- for i:=smin to smax do // Werte fenstern
+ for i:=smin to smax do // werte fenstern
for j:=0 to pmax do
werte[i*sstep+j*pstep]:=
- (werte[i*sstep+j*pstep]-offset)*fen.Werte[j];
+ (werte[i*sstep+j*pstep]-offset)*fen.werte[j];
end;
vorher:=0;
@@ -1037,8 +1039,8 @@ begin
in0:=true;
out0:=true;
- case sizeof(wgen) of
- sizeof(single):
+ case sizeOf(wgen) of
+ sizeOf(single):
for i:=smin to smax do begin
algo.laden(invers,pSingle(@(werte[i*sstep])),pstep);
algo.summen(true,vorher,in0);
@@ -1046,7 +1048,7 @@ begin
algo.summen(false,nachher,out0);
algo.speichern(invers,pSingle(@(werte[i*sstep])),pstep);
end;
- sizeof(double):
+ sizeOf(double):
for i:=smin to smax do begin
algo.laden(invers,pDouble(@(werte[i*sstep])),pstep);
algo.summen(true,vorher,in0);
@@ -1054,7 +1056,7 @@ begin
algo.summen(false,nachher,out0);
algo.speichern(invers,pDouble(@(werte[i*sstep])),pstep);
end;
- sizeof(extended):
+ sizeOf(extended):
for i:=smin to smax do begin
algo.laden(invers,pExtended(@(werte[i*sstep])),pstep);
algo.summen(true,vorher,in0);
@@ -1073,7 +1075,7 @@ begin
werte[i*sstep+j*pstep]:=
werte[i*sstep+j*pstep]+hg;
- gibAus(inttostr(byte(senkrecht))+' '+inttostr(byte(invers))+' (Parseval-Fehler = '+floattostr(pvFehler)+') ... nämlich von '+floattostr(vorher)+' zu '+floattostr(nachher),1);
+ gibAus(intToStr(byte(senkrecht))+' '+intToStr(byte(invers))+' (Parseval-Fehler = '+floatToStr(pvFehler)+') ... nämlich von '+floatToStr(vorher)+' zu '+floatToStr(nachher),1);
if in0 then gibAus('Nur Nullen im Input der FFT!',1);
if out0 then gibAus('Nur Nullen im Output der FFT!',1);
result:=not (in0 or out0);
@@ -1081,22 +1083,22 @@ end;
procedure tLLWerte.schreibeWert(var f: textfile; x,y: longint);
begin
- schreibeWert(f,x,y,werte[x+y*params.xsteps]);
+ schreibeWert(f,x,y,werte[x+y*params.xSteps]);
end;
procedure tLLWerte.schreibeWert(var f: textfile; x,y,wert: extended);
var
xa,ta: extended;
begin
- if params.xstop=params.xstart then
- xa:=params.xstop
+ if params.xStop=params.xStart then
+ xa:=params.xStop
else
- xa:=params.xstart+x/(params.xsteps-1)*(params.xstop-params.xstart);
- if params.tstop=params.tstart then
- ta:=params.tstop
+ xa:=params.xStart+x/(params.xSteps-1)*(params.xStop-params.xStart);
+ if params.tStop=params.tStart then
+ ta:=params.tStop
else
- ta:=params.tstart+y/(params.tsiz-1)*(params.tstop-params.tstart);
- writeln(f,floattostr(xa)+' '+floattostr(ta)+' '+floattostr(wert));
+ ta:=params.tStart+y/(params.tSiz-1)*(params.tStop-params.tStart);
+ writeln(f,floatToStr(xa)+' '+floatToStr(ta)+' '+floatToStr(wert));
end;
procedure tLLWerte.schreibeWertIntegriert(var f: textfile; i: longint; hor: boolean);
@@ -1106,14 +1108,14 @@ var
begin
tmp:=0;
if hor then begin
- for j:=0 to params.xsteps-1 do
- tmp:=tmp+werte[j+i*params.xsteps];
- schreibeWert(f,(params.xsteps-1)/2,i,tmp);
+ for j:=0 to params.xSteps-1 do
+ tmp:=tmp+werte[j+i*params.xSteps];
+ schreibeWert(f,(params.xSteps-1)/2,i,tmp);
end
else begin
- for j:=0 to params.tsiz-1 do
- tmp:=tmp+werte[i+j*params.xsteps];
- schreibeWert(f,i,(params.tsiz-1)/2,tmp);
+ for j:=0 to params.tSiz-1 do
+ tmp:=tmp+werte[i+j*params.xSteps];
+ schreibeWert(f,i,(params.tSiz-1)/2,tmp);
end;
end;
@@ -1123,21 +1125,21 @@ var
i: longint;
sum,x: extended;
begin
- assignfile(f,s);
+ assignFile(f,s);
rewrite(f);
sum:=0;
while x0<0 do
x0:=x0+dx;
- for i:=0 to params.xsteps*params.tsiz-1 do
+ for i:=0 to params.xSteps*params.tSiz-1 do
if i+1>x0 then begin
sum:=sum+werte[i]*(x0-i);
if senkrecht then
- x:=x0/(params.tsiz-1)*(params.tstop-params.tstart)+params.tstart
+ x:=x0/(params.tSiz-1)*(params.tStop-params.tStart)+params.tStart
else
- x:=x0/(params.xsteps-1)*(params.xstop-params.xstart)+params.xstart;
- writeln(f,floattostr(x)+' '+floattostr(sum/dx));
+ x:=x0/(params.xSteps-1)*(params.xStop-params.xStart)+params.xStart;
+ writeln(f,floatToStr(x)+' '+floatToStr(sum/dx));
if linien then begin
- writeln(f,floattostr(x)+' 0');
+ writeln(f,floatToStr(x)+' 0');
writeln(f)
end;
sum:=werte[i]*(i+1-x0);
@@ -1145,144 +1147,229 @@ begin
end
else
sum:=sum+werte[i];
- closefile(f);
+ closeFile(f);
end;
procedure tLLWerte.spiegle;
begin
- spiegle(0,params.tsiz-1);
+ spiegle(0,params.tSiz-1);
end;
-procedure tLLWerte.spiegle(tmin,tmax: longint);
+procedure tLLWerte.spiegle(tMin,tMax: longint);
var
i,j: longint;
tmp: wgen;
begin
- for i:=tmin to tmax do
- for j:=0 to params.xsteps div 2 -1 do begin
- tmp:=werte[j+i*params.xsteps];
- werte[j+i*params.xsteps]:=werte[params.xsteps-j-1+i*params.xsteps];
- werte[params.xsteps-j-1+i*params.xsteps]:=tmp;
+ for i:=tMin to tMax do
+ for j:=0 to params.xSteps div 2 -1 do begin
+ tmp:=werte[j+i*params.xSteps];
+ werte[j+i*params.xSteps]:=werte[params.xSteps-j-1+i*params.xSteps];
+ werte[params.xSteps-j-1+i*params.xSteps]:=tmp;
end;
end;
-procedure tLLWerte.fft2dNachbearbeitungA(nb: tFFTDatenordnung);
+procedure tLLWerte.fft2dNachbearbeitungA(nB: tFFTDatenordnung);
var
i: longint;
begin
- case NB of
+ case nB of
doResIms,doResSmi: ;
doBetr: begin
werte[0]:=abs(extended(werte[0])); // rein reell
- for i:=1 to params.xsteps div 2 -1 do begin // unterste Zeile ist reell in t
- werte[i]:=sqrt(sqr(extended(werte[i]))+sqr(extended(werte[params.xsteps-i])));
- werte[params.xsteps-i]:=werte[i];
+ for i:=1 to params.xSteps div 2 -1 do begin // unterste Zeile ist reell in t
+ werte[i]:=sqrt(sqr(extended(werte[i]))+sqr(extended(werte[params.xSteps-i])));
+ werte[params.xSteps-i]:=werte[i];
end;
- for i:=1 to params.xsteps div 2 -1 do begin // mittlere Zeile ist reell in t
- werte[i+(params.tsiz div 2)*params.xsteps]:=sqrt(sqr(extended(werte[i+(params.tsiz div 2)*params.xsteps]))+sqr(extended(werte[params.xsteps-i+(params.tsiz div 2)*params.xsteps])));
- werte[params.xsteps-i+(params.tsiz div 2)*params.xsteps]:=werte[i+(params.tsiz div 2)*params.xsteps];
+ for i:=1 to params.xSteps div 2 -1 do begin // mittlere Zeile ist reell in t
+ werte[i+(params.tSiz div 2)*params.xSteps]:=sqrt(sqr(extended(werte[i+(params.tSiz div 2)*params.xSteps]))+sqr(extended(werte[params.xSteps-i+(params.tSiz div 2)*params.xSteps])));
+ werte[params.xSteps-i+(params.tSiz div 2)*params.xSteps]:=werte[i+(params.tSiz div 2)*params.xSteps];
end;
- werte[params.xsteps div 2]:=abs(extended(werte[params.xsteps div 2])); // rein reell
- werte[params.tsiz div 2]:=abs(extended(werte[params.tsiz div 2])); // rein reell
- for i:=1 to params.tsiz div 2 -1 do begin // linkeste Spalte ist reell in x
- werte[i*params.xsteps]:=sqrt(sqr(extended(werte[i*params.xsteps]))+sqr(extended(werte[(params.tsiz-i)*params.xsteps])));
- werte[(params.tsiz-i)*params.xsteps]:=werte[i*params.xsteps];
+ werte[params.xSteps div 2]:=abs(extended(werte[params.xSteps div 2])); // rein reell
+ werte[params.tSiz div 2]:=abs(extended(werte[params.tSiz div 2])); // rein reell
+ for i:=1 to params.tSiz div 2 -1 do begin // linkeste Spalte ist reell in x
+ werte[i*params.xSteps]:=sqrt(sqr(extended(werte[i*params.xSteps]))+sqr(extended(werte[(params.tSiz-i)*params.xSteps])));
+ werte[(params.tSiz-i)*params.xSteps]:=werte[i*params.xSteps];
end;
- for i:=1 to params.tsiz div 2 -1 do begin // mittlere Spalte ist reell in x
- werte[params.xsteps div 2 + i*params.xsteps]:=sqrt(sqr(extended(werte[params.xsteps div 2 + i*params.xsteps]))+sqr(extended(werte[params.xsteps div 2 + (params.tsiz-i)*params.xsteps])));
- werte[params.xsteps div 2 + (params.tsiz-i)*params.xsteps]:=werte[params.xsteps div 2 + i*params.xsteps];
+ for i:=1 to params.tSiz div 2 -1 do begin // mittlere Spalte ist reell in x
+ werte[params.xSteps div 2 + i*params.xSteps]:=sqrt(sqr(extended(werte[params.xSteps div 2 + i*params.xSteps]))+sqr(extended(werte[params.xSteps div 2 + (params.tSiz-i)*params.xSteps])));
+ werte[params.xSteps div 2 + (params.tSiz-i)*params.xSteps]:=werte[params.xSteps div 2 + i*params.xSteps];
end;
end;
doBetrQdr: begin
werte[0]:=sqr(extended(werte[0])); // rein reell
- for i:=1 to params.xsteps div 2 -1 do begin // unterste Zeile ist reell in t
- werte[i]:=sqr(extended(werte[i]))+sqr(extended(werte[params.xsteps-i]));
- werte[params.xsteps-i]:=werte[i];
+ for i:=1 to params.xSteps div 2 -1 do begin // unterste Zeile ist reell in t
+ werte[i]:=sqr(extended(werte[i]))+sqr(extended(werte[params.xSteps-i]));
+ werte[params.xSteps-i]:=werte[i];
end;
- for i:=1 to params.xsteps div 2 -1 do begin // mittlere Zeile ist reell in t
- werte[i+(params.tsiz div 2)*params.xsteps]:=sqr(extended(werte[i+(params.tsiz div 2)*params.xsteps]))+sqr(extended(werte[params.xsteps-i+(params.tsiz div 2)*params.xsteps]));
- werte[params.xsteps-i+(params.tsiz div 2)*params.xsteps]:=werte[i+(params.tsiz div 2)*params.xsteps];
+ for i:=1 to params.xSteps div 2 -1 do begin // mittlere Zeile ist reell in t
+ werte[i+(params.tSiz div 2)*params.xSteps]:=sqr(extended(werte[i+(params.tSiz div 2)*params.xSteps]))+sqr(extended(werte[params.xSteps-i+(params.tSiz div 2)*params.xSteps]));
+ werte[params.xSteps-i+(params.tSiz div 2)*params.xSteps]:=werte[i+(params.tSiz div 2)*params.xSteps];
end;
- werte[params.xsteps div 2]:=sqr(extended(werte[params.xsteps div 2])); // rein reell
- werte[params.tsiz div 2]:=sqr(extended(werte[params.tsiz div 2])); // rein reell
- for i:=1 to params.tsiz div 2 -1 do begin // linkeste Spalte ist reell in x
- werte[i*params.xsteps]:=sqr(extended(werte[i*params.xsteps]))+sqr(extended(werte[(params.tsiz-i)*params.xsteps]));
- werte[(params.tsiz-i)*params.xsteps]:=werte[i*params.xsteps];
+ werte[params.xSteps div 2]:=sqr(extended(werte[params.xSteps div 2])); // rein reell
+ werte[params.tSiz div 2]:=sqr(extended(werte[params.tSiz div 2])); // rein reell
+ for i:=1 to params.tSiz div 2 -1 do begin // linkeste Spalte ist reell in x
+ werte[i*params.xSteps]:=sqr(extended(werte[i*params.xSteps]))+sqr(extended(werte[(params.tSiz-i)*params.xSteps]));
+ werte[(params.tSiz-i)*params.xSteps]:=werte[i*params.xSteps];
end;
- for i:=1 to params.tsiz div 2 -1 do begin // mittlere Spalte ist reell in x
- werte[params.xsteps div 2 + i*params.xsteps]:=sqr(extended(werte[params.xsteps div 2 + i*params.xsteps]))+sqr(extended(werte[params.xsteps div 2 + (params.tsiz-i)*params.xsteps]));
- werte[params.xsteps div 2 + (params.tsiz-i)*params.xsteps]:=werte[params.xsteps div 2 + i*params.xsteps];
+ for i:=1 to params.tSiz div 2 -1 do begin // mittlere Spalte ist reell in x
+ werte[params.xSteps div 2 + i*params.xSteps]:=sqr(extended(werte[params.xSteps div 2 + i*params.xSteps]))+sqr(extended(werte[params.xSteps div 2 + (params.tSiz-i)*params.xSteps]));
+ werte[params.xSteps div 2 + (params.tSiz-i)*params.xSteps]:=werte[params.xSteps div 2 + i*params.xSteps];
end;
end;
+ else
+ raise exception.create('Nachbearbeitungsmethode '+fftDoToStr(nB)+' nicht implementiert!');
end{of case};
end;
-procedure tLLWerte.fft2dNachbearbeitungB(xmin,xmax: longint; nb: tFFTDatenordnung);
+procedure tLLWerte.fft2dNachbearbeitungB(xMin,xMax: longint; nB: tFFTDatenordnung);
var
i,j: longint;
begin // bearbeitet nur den Hauptteil (außer erster und mittlerer Zeile/Spalte) nach!
- case nb of
+ case nB of
+ doResIms,doResSmi: ;
doBetr: begin
- for i:=xmin to xmax do
- for j:=1 to params.tsiz div 2 -1 do begin
- werte[i+j*params.xsteps]:=
- sqrt(sqr(extended(werte[i+j*params.xsteps]-werte[params.xsteps-i+(params.tsiz-j)*params.xsteps])) // Re^2
- +sqr(extended(werte[params.xsteps-i+j*params.xsteps]+werte[i+(params.tsiz-j)*params.xsteps]))); // Im^2
- werte[params.xsteps-i+j*params.xsteps]:=werte[i+j*params.xsteps];
- werte[i+(params.tsiz-j)*params.xsteps]:=werte[i+j*params.xsteps];
- werte[params.xsteps-i+(params.tsiz-j)*params.xsteps]:=werte[i+j*params.xsteps];
+ for i:=xMin to xMax do
+ for j:=1 to params.tSiz div 2 -1 do begin
+ werte[i+j*params.xSteps]:=
+ sqrt(sqr(extended(werte[i+j*params.xSteps]-werte[params.xSteps-i+(params.tSiz-j)*params.xSteps])) // Re^2
+ +sqr(extended(werte[params.xSteps-i+j*params.xSteps]+werte[i+(params.tSiz-j)*params.xSteps]))); // Im^2
+ werte[params.xSteps-i+j*params.xSteps]:=werte[i+j*params.xSteps];
+ werte[i+(params.tSiz-j)*params.xSteps]:=werte[i+j*params.xSteps];
+ werte[params.xSteps-i+(params.tSiz-j)*params.xSteps]:=werte[i+j*params.xSteps];
end;
end;
doBetrQdr: begin
- for i:=xmin to xmax do
- for j:=1 to params.tsiz div 2 -1 do begin
- werte[i+j*params.xsteps]:=
- sqr(extended(werte[i+j*params.xsteps]-werte[params.xsteps-i+(params.tsiz-j)*params.xsteps])) // Re^2
- +sqr(extended(werte[params.xsteps-i+j*params.xsteps]+werte[i+(params.tsiz-j)*params.xsteps])); // Im^2
- werte[params.xsteps-i+j*params.xsteps]:=werte[i+j*params.xsteps];
- werte[i+(params.tsiz-j)*params.xsteps]:=werte[i+j*params.xsteps];
- werte[params.xsteps-i+(params.tsiz-j)*params.xsteps]:=werte[i+j*params.xsteps];
+ for i:=xMin to xMax do
+ for j:=1 to params.tSiz div 2 -1 do begin
+ werte[i+j*params.xSteps]:=
+ sqr(extended(werte[i+j*params.xSteps]-werte[params.xSteps-i+(params.tSiz-j)*params.xSteps])) // Re^2
+ +sqr(extended(werte[params.xSteps-i+j*params.xSteps]+werte[i+(params.tSiz-j)*params.xSteps])); // Im^2
+ werte[params.xSteps-i+j*params.xSteps]:=werte[i+j*params.xSteps];
+ werte[i+(params.tSiz-j)*params.xSteps]:=werte[i+j*params.xSteps];
+ werte[params.xSteps-i+(params.tSiz-j)*params.xSteps]:=werte[i+j*params.xSteps];
end;
end;
+ else
+ raise exception.create('Nachbearbeitungsmethode '+fftDoToStr(nB)+' nicht implementiert!');
end{of case}
end;
-procedure tLLWerte.holeRam;
+procedure tLLWerte.fft2dNachbearbeitungVerdoppeln(nB: tFFTDatenordnung);
+var
+ i,j,xS2,tS4: int64;
+ reRe,reIm,imRe,imIm: extended;
begin
- holeRam(1);
+ // Vorsicht:
+ // Spalten sind zuerst tSiz/2 lang und dann tSiz.
+ // Zeilen behalten ihre Länge von xSteps.
+ xS2:=params.xSteps div 2;
+ tS4:=params.tSiz div 4;
+ case nB of
+ doAlleResSmi:
+ for j:=tS4 downto 0 do
+ for i:=xS2 downto 0 do begin
+ reRe:=werte[i + j*xS2];
+ if (i<>0) and (i<>xS2) then
+ imRe:=werte[-i + (j+1)*xS2]
+ else
+ imRe:=0; // erste und mittlere Spalte ist x-reell
+ if (j<>0) and (j<>tS4) then
+ reIm:=werte[i + (2*tS4-j)*xS2]
+ else
+ reIm:=0; // erste und mittlere Zeile ist t-reell
+ if (i<>0) and (i<>xS2) and (j<>0) and (j<>tS4) then
+ imIm:=werte[-i + (2*tS4-j+1)*xS2]
+ else
+ imIm:=0; // erste und mittlere Zeile und Spalte sind x-t-reell
+
+ werte[i + j *2*xS2]:=reRe-imIm;
+ werte[i + (4*tS4-j)*2*xS2]:=reIm+imRe;
+ if (i<>0) and (i<>xS2) then begin
+ werte[2*xS2-i + j *2*xS2]:= reRe+imIm;
+ werte[2*xS2-i + (4*tS4-j)*2*xS2]:=-imRe+reIm;
+ end;
+ if (j<>0) and (j<>2*tS4) then begin
+ werte[i + (2*tS4-j)*2*xS2]:=reRe+imIm;
+ werte[i + (2*tS4+j)*2*xS2]:=imRe-reIm;
+ if (i<>0) and (i<>xS2) then begin
+ werte[2*xS2-i + (2*tS4-j)*2*xS2]:= reRe-imIm;
+ werte[2*xS2-i + (2*tS4+j)*2*xS2]:=-imRe-reIm;
+ end;
+ end;
+ end;
+ doAlleResIms:
+ for j:=tS4 downto 0 do
+ for i:=xS2 downto 0 do begin
+ reRe:=werte[i + j*xS2];
+ if (i<>0) and (i<>xS2) then
+ imRe:=werte[-i + (j+1)*xS2]
+ else
+ imRe:=0; // erste und mittlere Spalte ist x-reell
+ if (j<>0) and (j<>tS4) then
+ reIm:=werte[i + (2*tS4-j)*xS2]
+ else
+ reIm:=0; // erste und mittlere Zeile ist t-reell
+ if (i<>0) and (i<>xS2) and (j<>0) and (j<>tS4) then
+ imIm:=werte[-i + (2*tS4-j+1)*xS2]
+ else
+ imIm:=0; // erste und mittlere Zeile und Spalte sind x-t-reell
+
+ werte[i + j *2*xS2]:=reRe-imIm;
+ werte[i + (2*tS4+j)*2*xS2]:=reIm+imRe;
+ if (i<>0) and (i<>xS2) then begin
+ werte[2*xS2-i + j *2*xS2]:= reRe+imIm;
+ werte[2*xS2-i + (2*tS4+j)*2*xS2]:=-imRe+reIm;
+ end;
+ if (j<>0) and (j<>2*tS4) then begin
+ werte[i + (2*tS4-j)*2*xS2]:=reRe+imIm;
+ werte[i + (4*tS4-j)*2*xS2]:=imRe-reIm;
+ if (i<>0) and (i<>xS2) then begin
+ werte[2*xS2-i + (2*tS4-j)*2*xS2]:= reRe-imIm;
+ werte[2*xS2-i + (4*tS4-j)*2*xS2]:=-imRe-reIm;
+ end;
+ end;
+ end;
+ else
+ raise exception.create('Nachbearbeitungsmethode '+fftDoToStr(nB)+' verdoppelt die Anzahl der Daten nicht!');
+ end{of case};
+end;
+
+procedure tLLWerte.holeRAM;
+begin
+ holeRAM(1);
end;
-procedure tLLWerte.holeRam(ausgaben: byte);
+procedure tLLWerte.holeRAM(ausgaben: byte);
begin
- holeRam(ausgaben,false);
+ holeRAM(ausgaben,false);
end;
-procedure tLLWerte.holeRam(ausgaben: byte; gemaeszTXMinMax: boolean);
+procedure tLLWerte.holeRAM(ausgaben: byte; gemaeszTXMinMax: boolean);
var
Zeit: extended;
br,ho: longint;
begin
Zeit:=now;
if gemaeszTXMinMax then begin
- br:=params.xsteps_;
- ho:=params.tsiz_;
+ br:=params.xSteps_;
+ ho:=params.tSiz_;
end
else begin
- br:=params.xsteps;
- ho:=params.tsiz;
+ br:=params.xSteps;
+ ho:=params.tSiz;
end;
if (ausgaben and __ausgabenMaske) <> 0 then
- gibAus('Fordere '+inttostr(floor(ho*br*sizeof(wgen)/1024/1024))+' MB RAM an ('+inttostr(br)+' x-Schritte mal '+inttostr(ho)+' t-Schritte; bisher '+inttostr(belegterSpeicher div 1024)+' MB belegt). ...',ausgaben);
+ gibAus('Fordere '+intToStr(floor(ho*br*sizeOf(wgen)/1024/1024))+' MB RAM an ('+intToStr(br)+' x-Schritte mal '+intToStr(ho)+' t-Schritte; bisher '+intToStr(belegterSpeicher div 1024)+' MB belegt). ...',ausgaben);
- setlength(werte,br*ho);
+ setLength(werte,br*ho);
if (ausgaben and __ausgabenMaske) <> 0 then
gibAus('... fertig '+timetostr(now-Zeit),ausgaben);
end;
-function tLLWerte.zuPixelWerten(whoehe,wbreite,xpmi,xmi,tmi: longint; xz,yz: extended; pPWerte: pTExtendedArray; pPAnzahlen: pTLongintArray): boolean;
+function tLLWerte.zuPixelWerten(wHoehe,wBreite,xPMi,xMi,tMi: longint; xZ,yZ: extended; pPWerte: pTExtendedArray; pPAnzahlen: pTLongintArray): boolean;
var
i,j,k,l,
- xv,xb,tv,tb: longint;
+ xV,xB,tV,tB: longint;
b: boolean;
begin
result:=false;
@@ -1291,33 +1378,33 @@ begin
pPAnzahlen^[i]:=0;
end;
b:=false;
- for j:=0 to whoehe-1 do
- for i:=0 to wbreite-1 do begin
- xv:=min(params.xsteps-1,max(0,ceil((i+max(0,xpmi)-1/2)/xz+xmi)));
- xb:=min(params.xsteps-1,max(0,ceil((i+max(0,xpmi)+1/2)/xz+xmi-1)));
- tv:=min(params.tsiz-1,max(0,ceil((j-1/2)/yz+tmi)));
- tb:=min(params.tsiz-1,max(0,ceil((j+1/2)/yz+tmi-1)));
- if xv>xb then begin
- if (i>0) or (xpmi>0) then
- dec(xv)
+ for j:=0 to wHoehe-1 do
+ for i:=0 to wBreite-1 do begin
+ xV:=min(params.xSteps-1,max(0,ceil((i+max(0,xPMi)-1/2)/xZ+xMi)));
+ xB:=min(params.xSteps-1,max(0,ceil((i+max(0,xPMi)+1/2)/xZ+xMi-1)));
+ tV:=min(params.tSiz-1,max(0,ceil((j-1/2)/yZ+tMi)));
+ tB:=min(params.tSiz-1,max(0,ceil((j+1/2)/yZ+tMi-1)));
+ if xV>xB then begin
+ if (i>0) or (xPMi>0) then
+ dec(xV)
else
- inc(xb);
+ inc(xB);
end;
- if tv>tb then begin
+ if tV>tB then begin
if j>0 then
- dec(tv)
+ dec(tV)
else
- inc(tb);
+ inc(tB);
end;
- if (xv>xb) or (tv>tb) then begin
- gibAus('Keine Inputwerte für Position '+inttostr(i)+':'+inttostr(j)+'!',1);
+ if (xV>xB) or (tV>tB) then begin
+ gibAus('Keine Inputwerte für Position '+intToStr(i)+':'+intToStr(j)+'!',1);
exit;
end;
- pPanzahlen^[j*wbreite+i]:=(xb-xv+1)*(tb-tv+1);
- for k:=xv to xb do
- for l:=tv to tb do begin
- b:=b or (werte[k+l*params.xsteps]<>0);
- pPWerte^[j*wbreite+i]:=pPWerte^[j*wbreite+i]+min(params.maxW,max(params.minW,werte[k+l*params.xsteps]));
+ pPAnzahlen^[j*wBreite+i]:=(xB-xV+1)*(tB-tV+1);
+ for k:=xV to xB do
+ for l:=tV to tB do begin
+ b:=b or (werte[k+l*params.xSteps]<>0);
+ pPWerte^[j*wBreite+i]:=pPWerte^[j*wBreite+i]+min(params.maxW,max(params.minW,werte[k+l*params.xSteps]));
end;
end;
if not b then
@@ -1325,254 +1412,254 @@ begin
result:=true;
end;
-function tLLWerte.findeSchwellwerte(xmi,xma,tmi,tma: longint; Schw: extended): tExtPointArray;
+function tLLWerte.findeSchwellwerte(xMi,xMa,tMi,tMa: longint; Schw: extended): tExtPointArray;
var
i,j,k,l,m,vz: longint;
dx,dy,x0,y0: extended;
begin
- setlength(result,0);
- gibAus('Schwellwerte finden ('+inttostr(xmi)+'-'+inttostr(xma)+') '+floattostr(Schw)+' ...',1);
+ setLength(result,0);
+ gibAus('Schwellwerte finden ('+intToStr(xMi)+'-'+intToStr(xMa)+') '+floatToStr(Schw)+' ...',1);
i:=0;
- dx:=(params.xstop-params.xstart)/(params.xsteps-1);
- x0:=params.xstart;
- dy:=(params.tstop-params.tstart)/(params.tsiz-1);
- y0:=params.tstart;
- for j:=xmi to xma do begin
- for k:=tmi to tma do begin
+ dx:=(params.xStop-params.xStart)/(params.xSteps-1);
+ x0:=params.xStart;
+ dy:=(params.tStop-params.tStart)/(params.tSiz-1);
+ y0:=params.tStart;
+ for j:=xMi to xMa do begin
+ for k:=tMi to tMa do begin
vz:=0;
for l:=0 to 1 do
for m:=0 to 1 do
vz:=
- vz or (byte(werte[j-l+(k-m)*params.xsteps]>=Schw) shl 1) or
- byte(werte[j-l+(k-m)*params.xsteps]<=Schw);
+ vz or (byte(werte[j-l+(k-m)*params.xSteps]>=Schw) shl 1) or
+ byte(werte[j-l+(k-m)*params.xSteps]<=Schw);
if vz=3 then begin
if i>=length(result) then
- setlength(result,length(result)+Speicherhappen);
+ setLength(result,length(result)+speicherHappen);
result[i]['x']:=j*dx+x0;
result[i]['y']:=k*dy+y0;
inc(i);
end;
end;
- if (xma-j) and $ff = 0 then
- gibAus('x = '+inttostr(j)+' ('+inttostr(xmi)+'-'+inttostr(xma)+')',1);
+ if (xMa-j) and $ff = 0 then
+ gibAus('x = '+intToStr(j)+' ('+intToStr(xMi)+'-'+intToStr(xMa)+')',1);
end;
gibAus('... fertig!',1);
- setlength(result,i);
+ setLength(result,i);
end;
-procedure tLLWerte.integriereSingle(qu: pTLLWerteSingle; xmi,xma,tmi,tma,xof,tof: longint; richtung: tIntegrationsRichtung);
+procedure tLLWerte.integriereSingle(qu: pTLLWerteSingle; xMi,xMa,tMi,tMa,xOf,tOf: longint; richtung: tIntegrationsRichtung);
var
i,j: longint;
int,faktor: extended;
begin
case richtung of
irHorizontal: begin
- faktor:=(qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1);
- for i:=tmi to tma do begin
+ faktor:=(qu^.params.xStop-qu^.params.xStart)/(qu^.params.xSteps-1);
+ for i:=tMi to tMa do begin
int:=0;
- for j:=0 to xmi-1 do
- int:=int+qu^.werte[j + i*qu^.params.xsteps];
- for j:=xmi to xma do begin
- int:=int+qu^.werte[j + i*qu^.params.xsteps];
- werte[j-xof + (i-tof)*params.xsteps]:=int*faktor;
+ for j:=0 to xMi-1 do
+ int:=int+qu^.werte[j + i*qu^.params.xSteps];
+ for j:=xMi to xMa do begin
+ int:=int+qu^.werte[j + i*qu^.params.xSteps];
+ werte[j-xOf + (i-tOf)*params.xSteps]:=int*faktor;
end;
end;
end;
irEinfall: begin
faktor:=
sqrt(
- sqr((qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1)) +
- sqr((qu^.params.tstop-qu^.params.tstart)/(qu^.params.tsiz-1)));
- gibAus('dx = '+floattostr((qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1)),1);
- gibAus('dt = '+floattostr((qu^.params.tstop-qu^.params.tstart)/(qu^.params.tsiz-1)),1);
- for i:=tmi to tma do begin // von links eintretendes (inkl. Ecke links unten)
+ sqr((qu^.params.xStop-qu^.params.xStart)/(qu^.params.xSteps-1)) +
+ sqr((qu^.params.tStop-qu^.params.tStart)/(qu^.params.tSiz-1)));
+ gibAus('dx = '+floatToStr((qu^.params.xStop-qu^.params.xStart)/(qu^.params.xSteps-1)),1);
+ gibAus('dt = '+floatToStr((qu^.params.tStop-qu^.params.tStart)/(qu^.params.tSiz-1)),1);
+ for i:=tMi to tMa do begin // von links eintretendes (inkl. Ecke links unten)
int:=0;
- for j:=1 to min(xmi,i) do
- int:=int+qu^.werte[xmi-j + (i-j)*qu^.params.xsteps];
- for j:=0 to min(tma-i,xma-xmi) do begin
- int:=int+qu^.werte[xmi+j + (i+j)*qu^.params.xsteps];
- werte[j+xmi-xof + (i+j-tof)*params.xsteps]:=int*faktor;
+ for j:=1 to min(xMi,i) do
+ int:=int+qu^.werte[xMi-j + (i-j)*qu^.params.xSteps];
+ for j:=0 to min(tMa-i,xMa-xMi) do begin
+ int:=int+qu^.werte[xMi+j + (i+j)*qu^.params.xSteps];
+ werte[j+xMi-xOf + (i+j-tOf)*params.xSteps]:=int*faktor;
end;
end;
- for i:=xmi+1 to xma do begin // von unten eintretendes (exkl. Ecke links unten)
+ for i:=xMi+1 to xMa do begin // von unten eintretendes (exkl. Ecke links unten)
int:=0;
- for j:=1 to min(tmi,i) do
- int:=int+qu^.werte[i-j + (tmi-j)*qu^.params.xsteps];
- for j:=0 to min(tma-tmi,xma-i) do begin
- int:=int+qu^.werte[i+j + (tmi+j)*qu^.params.xsteps];
- werte[i+j-xof + (tmi+j-tof)*params.xsteps]:=int*faktor;
+ for j:=1 to min(tMi,i) do
+ int:=int+qu^.werte[i-j + (tMi-j)*qu^.params.xSteps];
+ for j:=0 to min(tMa-tMi,xMa-i) do begin
+ int:=int+qu^.werte[i+j + (tMi+j)*qu^.params.xSteps];
+ werte[i+j-xOf + (tMi+j-tOf)*params.xSteps]:=int*faktor;
end;
end;
end;
irAusfall: begin
faktor:=
sqrt(
- sqr((qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1)) +
- sqr((qu^.params.tstop-qu^.params.tstart)/(qu^.params.tsiz-1)));
- gibAus('dx = '+floattostr((qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1)),1);
- gibAus('dt = '+floattostr((qu^.params.tstop-qu^.params.tstart)/(qu^.params.tsiz-1)),1);
- for i:=tmi to tma do begin // nach links austretendes (inkl. Ecke links oben)
+ sqr((qu^.params.xStop-qu^.params.xStart)/(qu^.params.xSteps-1)) +
+ sqr((qu^.params.tStop-qu^.params.tStart)/(qu^.params.tSiz-1)));
+ gibAus('dx = '+floatToStr((qu^.params.xStop-qu^.params.xStart)/(qu^.params.xSteps-1)),1);
+ gibAus('dt = '+floatToStr((qu^.params.tStop-qu^.params.tStart)/(qu^.params.tSiz-1)),1);
+ for i:=tMi to tMa do begin // nach links austretendes (inkl. Ecke links oben)
int:=0;
- for j:=1 to min(xmi,qu^.params.tsiz-1-i) do
- int:=int+qu^.werte[xmi-j + (i+j)*qu^.params.xsteps];
- for j:=0 to min(i-tmi,xma-xmi) do begin
- int:=int+qu^.werte[xmi+j + (i-j)*qu^.params.xsteps];
- werte[j+xmi-xof + (i-j-tof)*params.xsteps]:=int*faktor;
+ for j:=1 to min(xMi,qu^.params.tSiz-1-i) do
+ int:=int+qu^.werte[xMi-j + (i+j)*qu^.params.xSteps];
+ for j:=0 to min(i-tMi,xMa-xMi) do begin
+ int:=int+qu^.werte[xMi+j + (i-j)*qu^.params.xSteps];
+ werte[j+xMi-xOf + (i-j-tOf)*params.xSteps]:=int*faktor;
end;
end;
- for i:=xmi+1 to xma do begin // nach oben austretendes (exkl. Ecke links oben)
+ for i:=xMi+1 to xMa do begin // nach oben austretendes (exkl. Ecke links oben)
int:=0;
- for j:=1 to min(qu^.params.tsiz-1-tma,i) do
- int:=int+qu^.werte[i-j + (tma+j)*qu^.params.xsteps];
- for j:=0 to min(tma-tmi,xma-i) do begin
- int:=int+qu^.werte[i+j + (tma-j)*qu^.params.xsteps];
- werte[i+j-xof + (tma-j-tof)*params.xsteps]:=int*faktor;
+ for j:=1 to min(qu^.params.tSiz-1-tMa,i) do
+ int:=int+qu^.werte[i-j + (tMa+j)*qu^.params.xSteps];
+ for j:=0 to min(tMa-tMi,xMa-i) do begin
+ int:=int+qu^.werte[i+j + (tMa-j)*qu^.params.xSteps];
+ werte[i+j-xOf + (tMa-j-tOf)*params.xSteps]:=int*faktor;
end;
end;
end;
end{of case};
end;
-procedure tLLWerte.integriereDouble(qu: pTLLWerteDouble; xmi,xma,tmi,tma,xof,tof: longint; richtung: tIntegrationsRichtung);
+procedure tLLWerte.integriereDouble(qu: pTLLWerteDouble; xMi,xMa,tMi,tMa,xOf,tOf: longint; richtung: tIntegrationsRichtung);
var
i,j: longint;
int,faktor: extended;
begin
case richtung of
irHorizontal: begin
- faktor:=(qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1);
- for i:=tmi to tma do begin
+ faktor:=(qu^.params.xStop-qu^.params.xStart)/(qu^.params.xSteps-1);
+ for i:=tMi to tMa do begin
int:=0;
- for j:=0 to xmi-1 do
- int:=int+qu^.werte[j + i*qu^.params.xsteps];
- for j:=xmi to xma do begin
- int:=int+qu^.werte[j + i*qu^.params.xsteps];
- werte[j-xof + (i-tof)*params.xsteps]:=int*faktor;
+ for j:=0 to xMi-1 do
+ int:=int+qu^.werte[j + i*qu^.params.xSteps];
+ for j:=xMi to xMa do begin
+ int:=int+qu^.werte[j + i*qu^.params.xSteps];
+ werte[j-xOf + (i-tOf)*params.xSteps]:=int*faktor;
end;
end;
end;
irEinfall: begin
faktor:=
sqrt(
- sqr((qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1)) +
- sqr((qu^.params.tstop-qu^.params.tstart)/(qu^.params.tsiz-1)));
- gibAus('dx = '+floattostr((qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1)),1);
- gibAus('dt = '+floattostr((qu^.params.tstop-qu^.params.tstart)/(qu^.params.tsiz-1)),1);
- for i:=tmi to tma do begin // von links eintretendes (inkl. Ecke links unten)
+ sqr((qu^.params.xStop-qu^.params.xStart)/(qu^.params.xSteps-1)) +
+ sqr((qu^.params.tStop-qu^.params.tStart)/(qu^.params.tSiz-1)));
+ gibAus('dx = '+floatToStr((qu^.params.xStop-qu^.params.xStart)/(qu^.params.xSteps-1)),1);
+ gibAus('dt = '+floatToStr((qu^.params.tStop-qu^.params.tStart)/(qu^.params.tSiz-1)),1);
+ for i:=tMi to tMa do begin // von links eintretendes (inkl. Ecke links unten)
int:=0;
- for j:=1 to min(xmi,i) do
- int:=int+qu^.werte[xmi-j + (i-j)*qu^.params.xsteps];
- for j:=0 to min(tma-i,xma-xmi) do begin
- int:=int+qu^.werte[xmi+j + (i+j)*qu^.params.xsteps];
- werte[j+xmi-xof + (i+j-tof)*params.xsteps]:=int*faktor;
+ for j:=1 to min(xMi,i) do
+ int:=int+qu^.werte[xMi-j + (i-j)*qu^.params.xSteps];
+ for j:=0 to min(tMa-i,xMa-xMi) do begin
+ int:=int+qu^.werte[xMi+j + (i+j)*qu^.params.xSteps];
+ werte[j+xMi-xOf + (i+j-tOf)*params.xSteps]:=int*faktor;
end;
end;
- for i:=xmi+1 to xma do begin // von unten eintretendes (exkl. Ecke links unten)
+ for i:=xMi+1 to xMa do begin // von unten eintretendes (exkl. Ecke links unten)
int:=0;
- for j:=1 to min(tmi,i) do
- int:=int+qu^.werte[i-j + (tmi-j)*qu^.params.xsteps];
- for j:=0 to min(tma-tmi,xma-i) do begin
- int:=int+qu^.werte[i+j + (tmi+j)*qu^.params.xsteps];
- werte[i+j-xof + (tmi+j-tof)*params.xsteps]:=int*faktor;
+ for j:=1 to min(tMi,i) do
+ int:=int+qu^.werte[i-j + (tMi-j)*qu^.params.xSteps];
+ for j:=0 to min(tMa-tMi,xMa-i) do begin
+ int:=int+qu^.werte[i+j + (tMi+j)*qu^.params.xSteps];
+ werte[i+j-xOf + (tMi+j-tOf)*params.xSteps]:=int*faktor;
end;
end;
end;
irAusfall: begin
faktor:=
sqrt(
- sqr((qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1)) +
- sqr((qu^.params.tstop-qu^.params.tstart)/(qu^.params.tsiz-1)));
- gibAus('dx = '+floattostr((qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1)),1);
- gibAus('dt = '+floattostr((qu^.params.tstop-qu^.params.tstart)/(qu^.params.tsiz-1)),1);
- for i:=tmi to tma do begin // nach links austretendes (inkl. Ecke links oben)
+ sqr((qu^.params.xStop-qu^.params.xStart)/(qu^.params.xSteps-1)) +
+ sqr((qu^.params.tStop-qu^.params.tStart)/(qu^.params.tSiz-1)));
+ gibAus('dx = '+floatToStr((qu^.params.xStop-qu^.params.xStart)/(qu^.params.xSteps-1)),1);
+ gibAus('dt = '+floatToStr((qu^.params.tStop-qu^.params.tStart)/(qu^.params.tSiz-1)),1);
+ for i:=tMi to tMa do begin // nach links austretendes (inkl. Ecke links oben)
int:=0;
- for j:=1 to min(xmi,qu^.params.tsiz-1-i) do
- int:=int+qu^.werte[xmi-j + (i+j)*qu^.params.xsteps];
- for j:=0 to min(i-tmi,xma-xmi) do begin
- int:=int+qu^.werte[xmi+j + (i-j)*qu^.params.xsteps];
- werte[j+xmi-xof + (i-j-tof)*params.xsteps]:=int*faktor;
+ for j:=1 to min(xMi,qu^.params.tSiz-1-i) do
+ int:=int+qu^.werte[xMi-j + (i+j)*qu^.params.xSteps];
+ for j:=0 to min(i-tMi,xMa-xMi) do begin
+ int:=int+qu^.werte[xMi+j + (i-j)*qu^.params.xSteps];
+ werte[j+xMi-xOf + (i-j-tOf)*params.xSteps]:=int*faktor;
end;
end;
- for i:=xmi+1 to xma do begin // nach oben austretendes (exkl. Ecke links oben)
+ for i:=xMi+1 to xMa do begin // nach oben austretendes (exkl. Ecke links oben)
int:=0;
- for j:=1 to min(qu^.params.tsiz-1-tma,i) do
- int:=int+qu^.werte[i-j + (tma+j)*qu^.params.xsteps];
- for j:=0 to min(tma-tmi,xma-i) do begin
- int:=int+qu^.werte[i+j + (tma-j)*qu^.params.xsteps];
- werte[i+j-xof + (tma-j-tof)*params.xsteps]:=int*faktor;
+ for j:=1 to min(qu^.params.tSiz-1-tMa,i) do
+ int:=int+qu^.werte[i-j + (tMa+j)*qu^.params.xSteps];
+ for j:=0 to min(tMa-tMi,xMa-i) do begin
+ int:=int+qu^.werte[i+j + (tMa-j)*qu^.params.xSteps];
+ werte[i+j-xOf + (tMa-j-tOf)*params.xSteps]:=int*faktor;
end;
end;
end;
end{of case};
end;
-procedure tLLWerte.integriereExtended(qu: pTLLWerteDouble; xmi,xma,tmi,tma,xof,tof: longint; richtung: tIntegrationsRichtung);
+procedure tLLWerte.integriereExtended(qu: pTLLWerteDouble; xMi,xMa,tMi,tMa,xOf,tOf: longint; richtung: tIntegrationsRichtung);
var
i,j: longint;
int,faktor: extended;
begin
case richtung of
irHorizontal: begin
- faktor:=(qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1);
- for i:=tmi to tma do begin
+ faktor:=(qu^.params.xStop-qu^.params.xStart)/(qu^.params.xSteps-1);
+ for i:=tMi to tMa do begin
int:=0;
- for j:=0 to xmi-1 do
- int:=int+qu^.werte[j + i*qu^.params.xsteps];
- for j:=xmi to xma do begin
- int:=int+qu^.werte[j + i*qu^.params.xsteps];
- werte[j-xof + (i-tof)*params.xsteps]:=int*faktor;
+ for j:=0 to xMi-1 do
+ int:=int+qu^.werte[j + i*qu^.params.xSteps];
+ for j:=xMi to xMa do begin
+ int:=int+qu^.werte[j + i*qu^.params.xSteps];
+ werte[j-xOf + (i-tOf)*params.xSteps]:=int*faktor;
end;
end;
end;
irEinfall: begin
faktor:=
sqrt(
- sqr((qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1)) +
- sqr((qu^.params.tstop-qu^.params.tstart)/(qu^.params.tsiz-1)));
- gibAus('dx = '+floattostr((qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1)),1);
- gibAus('dt = '+floattostr((qu^.params.tstop-qu^.params.tstart)/(qu^.params.tsiz-1)),1);
- for i:=tmi to tma do begin // von links eintretendes (inkl. Ecke links unten)
+ sqr((qu^.params.xStop-qu^.params.xStart)/(qu^.params.xSteps-1)) +
+ sqr((qu^.params.tStop-qu^.params.tStart)/(qu^.params.tSiz-1)));
+ gibAus('dx = '+floatToStr((qu^.params.xStop-qu^.params.xStart)/(qu^.params.xSteps-1)),1);
+ gibAus('dt = '+floatToStr((qu^.params.tStop-qu^.params.tStart)/(qu^.params.tSiz-1)),1);
+ for i:=tMi to tMa do begin // von links eintretendes (inkl. Ecke links unten)
int:=0;
- for j:=1 to min(xmi,i) do
- int:=int+qu^.werte[xmi-j + (i-j)*qu^.params.xsteps];
- for j:=0 to min(tma-i,xma-xmi) do begin
- int:=int+qu^.werte[xmi+j + (i+j)*qu^.params.xsteps];
- werte[j+xmi-xof + (i+j-tof)*params.xsteps]:=int*faktor;
+ for j:=1 to min(xMi,i) do
+ int:=int+qu^.werte[xMi-j + (i-j)*qu^.params.xSteps];
+ for j:=0 to min(tMa-i,xMa-xMi) do begin
+ int:=int+qu^.werte[xMi+j + (i+j)*qu^.params.xSteps];
+ werte[j+xMi-xOf + (i+j-tOf)*params.xSteps]:=int*faktor;
end;
end;
- for i:=xmi+1 to xma do begin // von unten eintretendes (exkl. Ecke links unten)
+ for i:=xMi+1 to xMa do begin // von unten eintretendes (exkl. Ecke links unten)
int:=0;
- for j:=1 to min(tmi,i) do
- int:=int+qu^.werte[i-j + (tmi-j)*qu^.params.xsteps];
- for j:=0 to min(tma-tmi,xma-i) do begin
- int:=int+qu^.werte[i+j + (tmi+j)*qu^.params.xsteps];
- werte[i+j-xof + (tmi+j-tof)*params.xsteps]:=int*faktor;
+ for j:=1 to min(tMi,i) do
+ int:=int+qu^.werte[i-j + (tMi-j)*qu^.params.xSteps];
+ for j:=0 to min(tMa-tMi,xMa-i) do begin
+ int:=int+qu^.werte[i+j + (tMi+j)*qu^.params.xSteps];
+ werte[i+j-xOf + (tMi+j-tOf)*params.xSteps]:=int*faktor;
end;
end;
end;
irAusfall: begin
faktor:=
sqrt(
- sqr((qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1)) +
- sqr((qu^.params.tstop-qu^.params.tstart)/(qu^.params.tsiz-1)));
- gibAus('dx = '+floattostr((qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1)),1);
- gibAus('dt = '+floattostr((qu^.params.tstop-qu^.params.tstart)/(qu^.params.tsiz-1)),1);
- for i:=tmi to tma do begin // nach links austretendes (inkl. Ecke links oben)
+ sqr((qu^.params.xStop-qu^.params.xStart)/(qu^.params.xSteps-1)) +
+ sqr((qu^.params.tStop-qu^.params.tStart)/(qu^.params.tSiz-1)));
+ gibAus('dx = '+floatToStr((qu^.params.xStop-qu^.params.xStart)/(qu^.params.xSteps-1)),1);
+ gibAus('dt = '+floatToStr((qu^.params.tStop-qu^.params.tStart)/(qu^.params.tSiz-1)),1);
+ for i:=tMi to tMa do begin // nach links austretendes (inkl. Ecke links oben)
int:=0;
- for j:=1 to min(xmi,qu^.params.tsiz-1-i) do
- int:=int+qu^.werte[xmi-j + (i+j)*qu^.params.xsteps];
- for j:=0 to min(i-tmi,xma-xmi) do begin
- int:=int+qu^.werte[xmi+j + (i-j)*qu^.params.xsteps];
- werte[j+xmi-xof + (i-j-tof)*params.xsteps]:=int*faktor;
+ for j:=1 to min(xMi,qu^.params.tSiz-1-i) do
+ int:=int+qu^.werte[xMi-j + (i+j)*qu^.params.xSteps];
+ for j:=0 to min(i-tMi,xMa-xMi) do begin
+ int:=int+qu^.werte[xMi+j + (i-j)*qu^.params.xSteps];
+ werte[j+xMi-xOf + (i-j-tOf)*params.xSteps]:=int*faktor;
end;
end;
- for i:=xmi+1 to xma do begin // nach oben austretendes (exkl. Ecke links oben)
+ for i:=xMi+1 to xMa do begin // nach oben austretendes (exkl. Ecke links oben)
int:=0;
- for j:=1 to min(qu^.params.tsiz-1-tma,i) do
- int:=int+qu^.werte[i-j + (tma+j)*qu^.params.xsteps];
- for j:=0 to min(tma-tmi,xma-i) do begin
- int:=int+qu^.werte[i+j + (tma-j)*qu^.params.xsteps];
- werte[i+j-xof + (tma-j-tof)*params.xsteps]:=int*faktor;
+ for j:=1 to min(qu^.params.tSiz-1-tMa,i) do
+ int:=int+qu^.werte[i-j + (tMa+j)*qu^.params.xSteps];
+ for j:=0 to min(tMa-tMi,xMa-i) do begin
+ int:=int+qu^.werte[i+j + (tMa-j)*qu^.params.xSteps];
+ werte[i+j-xOf + (tMa-j-tOf)*params.xSteps]:=int*faktor;
end;
end;
end;
@@ -1590,7 +1677,7 @@ var
aParams,nParams: longint; // Index der alten und neuen Parameter
parameter: array[0..1,boolean,0..3] of extended;
// dim0 nummeriert Parametersätze
- // dim1: Ableitung (true) oder Werte (false)
+ // dim1: Ableitung (true) oder werte (false)
// dim2: position, 1/breite, amplitude, hintergrund
fehlers: array[0..1] of extended;
t0,t1,t2,t3, // Zwischenergebnisse
@@ -1600,22 +1687,22 @@ var
ignBr,ignVersch: boolean; // Breite/Verschiebung am Anschlag!
begin
if senkrecht then begin
- qpSchritt:=params.xsteps; // Schritt in der Quelle parallel zur Fit-Richtung
+ qpSchritt:=params.xSteps; // Schritt in der Quelle parallel zur Fit-Richtung
qsSchritt:=1; // Schritt in der Quelle senkrecht zur Fit-Richtung
- zpSchritt:=params.xsteps; // Schritt im Ziel in positionsMitten-Richtung
+ zpSchritt:=params.xSteps; // Schritt im Ziel in positionsMitten-Richtung
zdSchritt:=1; // Schritt im Ziel in Daten-Richtung (= senkrecht zur Fit-Richtung)
- pMi:=params.tstart;
- pMa:=params.tstop;
- pLen:=params.tsiz;
+ pMi:=params.tStart;
+ pMa:=params.tStop;
+ pLen:=params.tSiz;
end
else begin
- qsSchritt:=params.xsteps;
+ qsSchritt:=params.xSteps;
qpSchritt:=1;
zdSchritt:=length(positionsMitten);
zpSchritt:=1;
- pMi:=params.xstart;
- pMa:=params.xstop;
- pLen:=params.xsteps;
+ pMi:=params.xStart;
+ pMa:=params.xStop;
+ pLen:=params.xSteps;
end;
maxBreite:=1/maxBreite;
@@ -1660,7 +1747,7 @@ begin
nParams:=aParams;
{$DEFINE gauszFitBerechneWerte}
- {$I gauszFit.inc} // Werte + Gradienten berechnen
+ {$I gauszFit.inc} // werte + Gradienten berechnen
{$UNDEF}
schrittFaktor:=1;
@@ -1696,7 +1783,7 @@ begin
end;
{$DEFINE gauszFitBerechneWerte}
- {$I gauszFit.inc} // Werte + Gradienten berechnen
+ {$I gauszFit.inc} // werte + Gradienten berechnen
{$UNDEF}
if fehlers[aParams]>2*fehlers[nParams] then begin
@@ -1718,20 +1805,20 @@ begin
end;
if schrittFaktor<1e-50 then
- fehler('Sehr kleiner Schrittfaktor ('+floattostr(schrittFaktor)+') beim Fitten!');
+ fehler('Sehr kleiner Schrittfaktor ('+floatToStr(schrittFaktor)+') beim Fitten!');
inc(zaehl);
{$IFDEF gauszFitStatus}
if (zaehl mod 10000)=0 then
gibAus(
- floattostr(fehlers[aParams])+' '+
- floattostr(qdrSumm)+' '+
- inttostr(byte((verbesserung<-10) or (fehlers[aParams]*100<qdrSumm)))+' '+
- inttostr(byte(ignVersch or (abs(schrittFaktor*parameter[aParams,true,0])<1)))+' '+
- inttostr(byte(ignBr or (abs(schrittFaktor*parameter[aParams,true,1]/parameter[aParams,false,1])<0.01)))+' '+
- inttostr(byte(abs(schrittFaktor*parameter[aParams,true,2]/parameter[aParams,false,2])<0.01))+' '+
- inttostr(byte(abs(schrittFaktor*parameter[aParams,true,3]/max(abs(parameter[aParams,false,3]),1e-10))<0.01))+' '+
- inttostr(verbesserung),
+ floatToStr(fehlers[aParams])+' '+
+ floatToStr(qdrSumm)+' '+
+ intToStr(byte((verbesserung<-10) or (fehlers[aParams]*100<qdrSumm)))+' '+
+ intToStr(byte(ignVersch or (abs(schrittFaktor*parameter[aParams,true,0])<1)))+' '+
+ intToStr(byte(ignBr or (abs(schrittFaktor*parameter[aParams,true,1]/parameter[aParams,false,1])<0.01)))+' '+
+ intToStr(byte(abs(schrittFaktor*parameter[aParams,true,2]/parameter[aParams,false,2])<0.01))+' '+
+ intToStr(byte(abs(schrittFaktor*parameter[aParams,true,3]/max(abs(parameter[aParams,false,3]),1e-10))<0.01))+' '+
+ intToStr(verbesserung),
3);
{$ENDIF}
@@ -1762,49 +1849,72 @@ var
i: int64;
begin
result:=0;
- for i:=0 to params.xsteps-1 do
+ for i:=0 to params.xSteps-1 do
result:=result + werte[i];
- for i:=1 to params.tsiz-2 do
- result:=result + werte[i*params.xsteps];
- for i:=0 to params.xsteps-1 do
- result:=result + werte[i + (params.tsiz-1)*params.xsteps];
- for i:=1 to params.tsiz-2 do
- result:=result + werte[params.xsteps-1 + i*params.xsteps];
+ for i:=1 to params.tSiz-2 do
+ result:=result + werte[i*params.xSteps];
+ for i:=0 to params.xSteps-1 do
+ result:=result + werte[i + (params.tSiz-1)*params.xSteps];
+ for i:=1 to params.tSiz-2 do
+ result:=result + werte[params.xSteps-1 + i*params.xSteps];
result:=
- result/2/(params.xsteps+params.tsiz-2);
+ result/2/(params.xSteps+params.tSiz-2);
end;
-procedure tLLWerte.filtereHoheFrequenzen(betraege: tLLWerte; xFak,yFak: extended);
+procedure tLLWerte.kantenFilter(betraege: tLLWerte; xFak,yFak: extended; filterTyp: tKantenFilterTyp);
+var
+ dummy: tIntPoint;
+begin
+ kantenFilter(betraege,xFak,yFak,filterTyp,false,dummy);
+end;
+
+procedure tLLWerte.kantenFilter(betraege: tLLWerte; xFak,yFak: extended; filterTyp: tKantenFilterTyp; einseitig: boolean; out maxPos: tIntPoint);
var
maxima: tIntPointArray;
- i,im,j,jm,mCnt: int64;
+ i,iM,j,jM,mCnt,di,dj: int64;
wert,minWert,maxWert: extended;
+ istVollKomplex: byte; // 1=nein, 2=ja
+ schiebung: tIntPoint;
begin
- setlength(maxima,0);
+ istVollKomplex:=(params.tSiz div betraege.params.tSiz);
+ if (betraege.params.tSiz*istVollKomplex <> params.tSiz) or
+ (betraege.params.xSteps <> params.xSteps) or
+ (not (istVollKomplex in [1,2])) then
+ raise exception.create(
+ 'Die Dimension der Beträge ('+intToStr(betraege.params.xSteps)+' x '+intToStr(betraege.params.tSiz)+') stimmt nicht mit '+
+ 'der Dimension der Werte ('+intToStr(params.xSteps)+' x '+intToStr(params.tSiz)+') -- oder deren ersten t-Hälfte -- überein ('+intToStr(istVollKomplex)+')!');
+ if einseitig then begin
+ if istVollKomplex<>2 then
+ raise exception.create('Kann nur voll komplexe Werte einseitig per Kantenfilter filtern!');
+ if filterTyp<>kfHochpass then
+ raise exception.create('Kann nur einen Hochpass als einseitigen Kantenfilter verwenden!');
+ end;
+
+ setLength(maxima,0);
mCnt:=0;
- for j:=0 to params.tsiz div 2 + 1 do begin
- jm:=j - 1 + params.tsiz*byte(j=0);
- for i:=0 to params.xsteps div 2 + 1 do begin
- im:=i - 1 + params.xsteps*byte(i=0);
- wert:=betraege.werte[i+j*params.xsteps];
+ for j:=0 to betraege.params.tSiz div 2 + 1 do begin
+ jM:=j - 1 + betraege.params.tSiz*byte(j=0);
+ for i:=0 to betraege.params.xSteps div 2 + 1 do begin
+ iM:=i - 1 + betraege.params.xSteps*byte(i=0);
+ wert:=betraege.werte[i+j*betraege.params.xSteps];
if
- (wert > betraege.werte[im+j*params.xsteps]) and
- (wert > betraege.werte[i+jm*params.xsteps]) and
- (wert > betraege.werte[(i+1)+j*params.xsteps]) and
- (wert > betraege.werte[i+(j+1)*params.xsteps]) then begin
+ (wert > betraege.werte[iM+j*betraege.params.xSteps]) and
+ (wert > betraege.werte[i+jM*betraege.params.xSteps]) and
+ (wert > betraege.werte[(i+1)+j*betraege.params.xSteps]) and
+ (wert > betraege.werte[i+(j+1)*betraege.params.xSteps]) then begin
if length(maxima)<=mCnt then
- setlength(maxima,length(maxima)+1024);
+ setLength(maxima,length(maxima)+1024);
maxima[mCnt]['x']:=i;
maxima[mCnt]['y']:=j;
inc(mCnt);
end;
end;
end;
- setlength(maxima,mCnt);
- writeln(length(maxima),' (von ',params.xsteps*params.tsiz,')');
+ setLength(maxima,mCnt);
+ writeln(length(maxima),' (von ',betraege.params.xSteps*betraege.params.tSiz,')');
betraege.sortiereMaxima(maxima);
- mCnt:=1;
+ maxPos:=maxima[1];
maxWert:=0;
for i:=1 to length(maxima)-1 do begin
minWert:=0;
@@ -1818,34 +1928,72 @@ begin
end;
if (i=1) or (minWert>maxWert) then begin
maxWert:=minWert;
- mCnt:=i;
+ maxPos:=maxima[i];
end;
end;
- im:=params.xsteps div 2 + 1;
- jm:=params.tsiz div 2 + 1;
- for j:=0 to jm do
- for i:=0 to im do begin
- wert:=(sqr(i)*xFak+sqr(j)*yFak)/(sqr(maxima[mCnt]['x'])*xFak+sqr(maxima[mCnt]['y'])*yFak);
- if wert > 0.6 then
- wert:=0
- else if wert > 0.4 then
- wert:=(1+cos((wert-0.4)/0.2*pi))/2
- else
- wert:=1;
-
- werte[i+j*params.xsteps]:=
- werte[i+j*params.xsteps]*wert;
- if (i>0) and (i<im) then
- werte[params.xsteps-i+j*params.xsteps]:=
- werte[params.xsteps-i+j*params.xsteps]*wert;
- if (j>0) and (j<jm) then
- werte[i+(params.tsiz-j)*params.xsteps]:=
- werte[i+(params.tsiz-j)*params.xsteps]*wert;
- if (i>0) and (i<im) and (j>0) and (j<jm) then
- werte[params.xsteps-i+(params.tsiz-j)*params.xsteps]:=
- werte[params.xsteps-i+(params.tsiz-j)*params.xsteps]*wert;
+ if istVollKomplex=1 then begin
+ iM:=params.xSteps div 2 + 1;
+ jM:=params.tSiz div 2 + 1;
+ for j:=0 to jM do
+ for i:=0 to iM do begin
+ wert:=(sqr(i)*xFak+sqr(j)*yFak)/(sqr(maxPos['x'])*xFak+sqr(maxPos['y'])*yFak);
+ if wert > 0.6 then
+ wert:=0
+ else if wert > 0.4 then
+ wert:=(1+cos((wert-0.4)/0.2*pi))/2
+ else
+ wert:=1;
+ if filterTyp=kfHochpass then
+ wert:=1-wert;
+
+ werte[i+j*params.xSteps]:=
+ werte[i+j*params.xSteps]*wert;
+ if (i>0) and (i<iM) then
+ werte[params.xSteps-i+j*params.xSteps]:=
+ werte[params.xSteps-i+j*params.xSteps]*wert;
+ if (j>0) and (j<jM) then
+ werte[i+(params.tSiz-j)*params.xSteps]:=
+ werte[i+(params.tSiz-j)*params.xSteps]*wert;
+ if (i>0) and (i<iM) and (j>0) and (j<jM) then
+ werte[params.xSteps-i+(params.tSiz-j)*params.xSteps]:=
+ werte[params.xSteps-i+(params.tSiz-j)*params.xSteps]*wert;
+ end;
+ end
+ else begin
+ if einseitig then begin
+ schiebung:=maxPos;
+ filterTyp:=kfTiefpass;
+ end
+ else
+ schiebung:=intPoint(0,0);
+ iM:=params.xSteps;
+ jM:=params.tSiz div 2;
+ for j:=0 to jM-1 do begin
+ dj:=abs(j-schiebung['y']);
+ if jM-dj<dj then
+ dj:=jM-dj;
+ for i:=0 to iM-1 do begin
+ di:=abs(i-schiebung['x']);
+ if iM-di<di then
+ di:=iM-di;
+ wert:=(sqr(di)*xFak+sqr(dj)*yFak)/(sqr(maxPos['x'])*xFak+sqr(maxPos['y'])*yFak);
+ if wert > 0.6 then
+ wert:=0
+ else if wert > 0.4 then
+ wert:=(1+cos((wert-0.4)/0.2*pi))/2
+ else
+ wert:=1;
+ if filterTyp=kfHochpass then
+ wert:=1-wert;
+
+ werte[i+j*params.xSteps]:= // Re
+ werte[i+j*params.xSteps]*wert;
+ werte[i+(jM+j)*params.xSteps]:= // Im
+ werte[i+(jM+j)*params.xSteps]*wert;
+ end;
end;
+ end;
end;
procedure tLLWerte.fenstereWerte(xMi,xMa,tMi,tMa: int64; xFen,tFen: tFenster; hg: extended);
@@ -1854,8 +2002,8 @@ var
begin
for j:=tMi to tMa do
for i:=xMi to xMa do
- werte[i+j*params.xsteps]:=
- (werte[i+j*params.xsteps]-hg)*xFen.Werte[i]*tFen.Werte[j];
+ werte[i+j*params.xSteps]:=
+ (werte[i+j*params.xSteps]-hg)*xFen.werte[i]*tFen.werte[j];
end;
// tWavelet ********************************************************************
@@ -1883,46 +2031,46 @@ var
tmpFFTAlgo: tFFTAlgorithmus;
begin
result:=false;
- werte.params.xsteps:=2;
- werte.params.transformationen.xstart:=0;
- werte.params.transformationen.xstop:=1;
- werte.params.transformationen.tstart:=0;
- werte.params.transformationen.tstop:=1;
+ werte.params.xSteps:=2;
+ werte.params.transformationen.xStart:=0;
+ werte.params.transformationen.xStop:=1;
+ werte.params.transformationen.tStart:=0;
+ werte.params.transformationen.tStop:=1;
if mitFFT then begin
- if round(power(2,round(ln(werte.params.tsiz)/ln(2))))<>werte.params.tsiz then begin
- gibAus('Waveletlänge muss eine Zweierpotenz sein bei Faltung mittels FFT, '+inttostr(werte.params.tsiz)+' ist das nicht!',3);
+ if round(power(2,round(ln(werte.params.tSiz)/ln(2))))<>werte.params.tSiz then begin
+ gibAus('Waveletlänge muss eine Zweierpotenz sein bei Faltung mittels FFT, '+intToStr(werte.params.tSiz)+' ist das nicht!',3);
exit;
end;
- werte.holeRam(1);
+ werte.holeRAM(1);
case typ of
wtSin2: begin
- hlen:=round(tfwhm);
- for i:=0 to hlen do begin
+ hLen:=round(tfwhm);
+ for i:=0 to hLen do begin
tmp:=sqr(cos(i*pi/2/tfwhm));
if i>0 then begin
- werte.werte[(werte.params.tsiz-i)*2]:= tmp*cos(-i*freq*2*pi);
- werte.werte[(werte.params.tsiz-i)*2+1]:=tmp*sin(-i*freq*2*pi);
+ werte.werte[(werte.params.tSiz-i)*2]:= tmp*cos(-i*freq*2*pi);
+ werte.werte[(werte.params.tSiz-i)*2+1]:=tmp*sin(-i*freq*2*pi);
end;
werte.werte[2*i]:= tmp*cos(i*freq*2*pi);
werte.werte[2*i+1]:=tmp*sin(i*freq*2*pi);
end;
- for i:=hlen+1 to werte.params.tsiz-1-hlen do begin
+ for i:=hLen+1 to werte.params.tSiz-1-hLen do begin
werte.werte[2*i]:=0;
werte.werte[2*i+1]:=0;
end;
- gibAus(inttostr(werte.params.xsteps)+' '+inttostr(werte.params.tsiz)+' '+inttostr(length(werte.werte)),1);
- tmpFFTAlgo:=createFFTAlgorithmus(2*hlen,doRes,doResIms);
+ gibAus(intToStr(werte.params.xSteps)+' '+intToStr(werte.params.tSiz)+' '+intToStr(length(werte.werte)),1);
+ tmpFFTAlgo:=createFFTAlgorithmus(2*hLen,doRes,doResIms);
werte.fft(true,false,tmpFFTAlgo,nil,0,pvFehler);
tmpFFTAlgo.free;
end;
wtFrequenzfenster: begin
- hlen:=werte.params.tsiz div 2;
- for i:=0 to hlen do begin
- werte.werte[2*i]:=Byte(tfwhm*Abs(i/werte.params.tsiz-freq)<=1); // Re=1 <=> |f-f_Mitte| < Laenge/T_fwhm
+ hLen:=werte.params.tSiz div 2;
+ for i:=0 to hLen do begin
+ werte.werte[2*i]:=byte(tfwhm*abs(i/werte.params.tSiz-freq)<=1); // Re=1 <=> |f-f_Mitte| < Laenge/T_fwhm
werte.werte[2*i+1]:=0; // Dummy-Wavelet
end;
- for i:=hlen+1 to 2*hlen-1 do begin
+ for i:=hLen+1 to 2*hLen-1 do begin
werte.werte[2*i]:=0; // Ims = 0
werte.werte[2*i+1]:=0; // Dummy-Wavelet
end;
@@ -1934,13 +2082,13 @@ begin
gibAus('Ich kann nur das ''Sin2''-Wavelet im Zeitbereich definieren!',3);
exit;
end;
- hlen:=round(tfwhm);
- werte.params.tsiz:=2*hlen+1;
- setlength(werte.werte,werte.params.xsteps*werte.params.tsiz);
- for i:=-hlen to hlen do begin
+ hLen:=round(tfwhm);
+ werte.params.tSiz:=2*hLen+1;
+ setLength(werte.werte,werte.params.xSteps*werte.params.tSiz);
+ for i:=-hLen to hLen do begin
tmp:=sqr(cos(i*pi/2/tfwhm));
- werte.werte[2*(i+hlen)]:= tmp*cos(i*freq*2*pi);
- werte.werte[2*(i+hlen)+1]:=tmp*sin(i*freq*2*pi);
+ werte.werte[2*(i+hLen)]:= tmp*cos(i*freq*2*pi);
+ werte.werte[2*(i+hLen)+1]:=tmp*sin(i*freq*2*pi);
end;
end;
nur0:=true;
@@ -1953,17 +2101,17 @@ end;
constructor tWavelet.create;
var
- ps: tExtrainfos;
+ ps: tExtraInfos;
begin
inherited create;
- ps:=tExtrainfos.create;
+ ps:=tExtraInfos.create;
werte:=tLLWerteDouble.create(ps);
pvFehler:=0;
end;
destructor tWavelet.destroy;
begin
- werte.params.Free;
+ werte.params.free;
werte.free;
inherited destroy;
end;
generated by cgit v1.2.3-70-g09d2 (git 2.47.0) at 2024-11-01 22:23:43 +0000