summaryrefslogtreecommitdiff
path: root/werteunit.pas
diff options
context:
space:
mode:
authorErich Eckner <git@eckner.net>2017-07-17 16:04:40 +0200
committerErich Eckner <git@eckner.net>2017-07-20 09:37:46 +0200
commit6b0861f3f2803f283f1797f5b43d20770c5cf80c (patch)
tree2b4fc6b80db4210640758317cb3fe226a5b0149e /werteunit.pas
parent8855bcb10bf294e4ce6f4c828352ec3114690b59 (diff)
downloadepost-6b0861f3f2803f283f1797f5b43d20770c5cf80c.tar.xz
any progress
Diffstat (limited to 'werteunit.pas')
-rw-r--r--werteunit.pas1650
1 files changed, 899 insertions, 751 deletions
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-02 02:24:13 +0000