diff options
Diffstat (limited to 'epostunit.pas')
| -rw-r--r-- | epostunit.pas | 329 |
1 files changed, 56 insertions, 273 deletions
diff --git a/epostunit.pas b/epostunit.pas index f36215b..6527891 100644 --- a/epostunit.pas +++ b/epostunit.pas @@ -244,7 +244,9 @@ type tProduktThread = class(tLogThread) xMi,xMa,tMi,tMa,tOf,xOf: longint; f1,f2,pro: tWerte; - constructor create(faktor1, faktor2, produkt: tWerte; xMin,xMax,tMin,tMax,xOff,tOff: longint); + daO: tFFTDatenordnung; + konj: boolean; + constructor create(faktor1, faktor2, produkt: tWerte; xMin,xMax,tMin,tMax,xOff,tOff: longint; datenOrdnung: tFFTDatenordnung; konjugiert: boolean); procedure stExecute; override; end; tBilderThread = class(tLogThread) @@ -2689,7 +2691,8 @@ function tWerte.berechneProdukt(sT: boolean; f: tMyStringList; threads, faktor1, var i,xMin,xMax,tMin,tMax: longint; s: string; - fertig: boolean; + fertig,konjugiert: boolean; + datenOrdnung: tFFTDatenordnung; produktThreads: array of tProduktThread; Zeit: extended; bekannteBefehle: tMyStringList; @@ -2709,6 +2712,8 @@ begin tMax:=_tSiz-1; _np:=wertes^[faktor1]._np; _beta:=wertes^[faktor1]._beta; + konjugiert:=false; + datenOrdnung:=doRes; Zeit:=now; bekannteBefehle:=tMyStringList.create; repeat @@ -2735,6 +2740,18 @@ begin tMax:=kont2disk('t',exprToFloat(sT,s)); continue; end; + if istDasBefehl('konjugiert',s,bekannteBefehle,false) then begin + konjugiert:=true; + continue; + end; + if istDasBefehl('Datenordnung:',s,bekannteBefehle,true) then begin + if not strToFftDo(datenOrdnung,s) then begin + gibAus('^ berechneProdukt',3); + bekannteBefehle.free; + exit; + end; + continue; + end; bekannteBefehle.sort; gibAus('Verstehe Option '''+s+''' nicht bei Multipliziere!'#10'Ich kenne:'#10+bekannteBefehle.text,3); bekannteBefehle.free; @@ -2742,6 +2759,21 @@ begin until false; bekannteBefehle.free; + if (datenOrdnung<>doRes) and ( + (xMin<>0) or + (tMin<>0) or + (xMax<>_xSteps-1) or + (tMax<>_tSiz-1) + ) then begin + gibAus('Datenordnung '+fftDoToStr(datenOrdnung)+' kann nicht gleichzeitig mit einem Koordinatenausschnitt bei einer Multiplikation verarbeitet werden!',3); + exit; + end; + + if konjugiert and not (datenOrdnung in [doResIms,doResSmi]) then begin + gibAus('Bei einer Multiplikation kann Datenordnung '+fftDoToStr(datenOrdnung)+' nicht komplex konjugiert werden - ich brauche auch Imaginärteile!',3); + exit; + end; + _xSteps:=xMax-xMin+1; _tSiz:=tMax-tMin+1; if (wertes^[faktor1].transformationen.xStart<>wertes^[faktor2].transformationen.xStart) or @@ -2766,7 +2798,7 @@ begin Zeit:=now; setLength(produktThreads,threads); for i:=0 to length(produktThreads)-1 do - produktThreads[i]:=tProduktThread.create(wertes^[faktor1],wertes^[faktor2],self,round(i*_xSteps/threads),round((i+1)*_xSteps/threads-1),0,_tSiz-1,xMin,tMin); + produktThreads[i]:=tProduktThread.create(wertes^[faktor1],wertes^[faktor2],self,round(i*_xSteps/threads),round((i+1)*_xSteps/threads-1),0,_tSiz-1,xMin,tMin,datenOrdnung,konjugiert); repeat sleep(10); fertig:=true; @@ -5591,193 +5623,43 @@ begin end; procedure tQuotientThread.stExecute; -var - i,j: longint; - i01,i02,o0: boolean; begin gibAus('Quotient-Berechnungsthread gestartet ...',1); - i01:=true; - i02:=true; - o0:=true; case dend.genauigkeit of gSingle: case sor.genauigkeit of gSingle: // single / single - for j:=tMi to tMa do begin - if (tMa-j) mod ((tMa-tMi) div 10) = 0 then - gibAus('Quotient-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1); - for i:=xMi to xMa do - if abs(sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps])<eps then - quot.eWerte.werte[i+j*quot._xSteps]:= - dend.sWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] / - eps*sign(sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]) - else - quot.eWerte.werte[i+j*quot._xSteps]:= - dend.sWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] / - sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]; - i01:=i01 and (dend.sWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps]=0); - i02:=i02 and (sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]=0); - o0:=o0 and (quot.eWerte.werte[i+j*quot._xSteps]=0); - end; + quot.eWerte.quotioent(pTLLWerteSingle(@dend.sWerte),pTLLWerteSingle(@sor.sWerte),xMi,xMa,xOf,tMi,tMa,tOf,eps); gDouble: // single / double - for j:=tMi to tMa do begin - if (tMa-j) mod ((tMa-tMi) div 10) = 0 then - gibAus('Quotient-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1); - for i:=xMi to xMa do begin - if abs(sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps])<eps then - quot.eWerte.werte[i+j*quot._xSteps]:= - dend.sWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] / - eps*sign(sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]) - else - quot.eWerte.werte[i+j*quot._xSteps]:= - dend.sWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] / - sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]; - i01:=i01 and (dend.sWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps]=0); - i02:=i02 and (sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]=0); - o0:=o0 and (quot.eWerte.werte[i+j*quot._xSteps]=0); - end; - end; + quot.eWerte.quotioent(pTLLWerteSingle(@dend.sWerte),pTLLWerteDouble(@sor.dWerte),xMi,xMa,xOf,tMi,tMa,tOf,eps); gExtended: // single / extended - for j:=tMi to tMa do begin - if (tMa-j) mod ((tMa-tMi) div 10) = 0 then - gibAus('Quotient-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1); - for i:=xMi to xMa do begin - if abs(sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps])<eps then - quot.eWerte.werte[i+j*quot._xSteps]:= - dend.sWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] / - eps*sign(sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]) - else - quot.eWerte.werte[i+j*quot._xSteps]:= - dend.sWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] / - sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]; - i01:=i01 and (dend.sWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps]=0); - i02:=i02 and (sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]=0); - o0:=o0 and (quot.eWerte.werte[i+j*quot._xSteps]=0); - end; - end; + quot.eWerte.quotioent(pTLLWerteSingle(@dend.sWerte),pTLLWerteExtended(@sor.eWerte),xMi,xMa,xOf,tMi,tMa,tOf,eps); end{of case}; gDouble: case sor.genauigkeit of gSingle: // double / single - for j:=tMi to tMa do begin - if (tMa-j) mod ((tMa-tMi) div 10) = 0 then - gibAus('Quotient-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1); - for i:=xMi to xMa do - if abs(sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps])<eps then - quot.eWerte.werte[i+j*quot._xSteps]:= - dend.dWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] / - eps*sign(sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]) - else - quot.eWerte.werte[i+j*quot._xSteps]:= - dend.dWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] / - sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]; - i01:=i01 and (dend.dWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps]=0); - i02:=i02 and (sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]=0); - o0:=o0 and (quot.eWerte.werte[i+j*quot._xSteps]=0); - end; + quot.eWerte.quotioent(pTLLWerteDouble(@dend.dWerte),pTLLWerteSingle(@sor.sWerte),xMi,xMa,xOf,tMi,tMa,tOf,eps); gDouble: // double / double - for j:=tMi to tMa do begin - if (tMa-j) mod ((tMa-tMi) div 10) = 0 then - gibAus('Quotient-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1); - for i:=xMi to xMa do begin - if abs(sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps])<eps then - quot.eWerte.werte[i+j*quot._xSteps]:= - dend.dWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] / - eps*sign(sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]) - else - quot.eWerte.werte[i+j*quot._xSteps]:= - dend.dWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] / - sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]; - i01:=i01 and (dend.dWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps]=0); - i02:=i02 and (sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]=0); - o0:=o0 and (quot.eWerte.werte[i+j*quot._xSteps]=0); - end; - end; + quot.eWerte.quotioent(pTLLWerteDouble(@dend.dWerte),pTLLWerteDouble(@sor.dWerte),xMi,xMa,xOf,tMi,tMa,tOf,eps); gExtended: // double / extended - for j:=tMi to tMa do begin - if (tMa-j) mod ((tMa-tMi) div 10) = 0 then - gibAus('Quotient-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1); - for i:=xMi to xMa do begin - if abs(sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps])<eps then - quot.eWerte.werte[i+j*quot._xSteps]:= - dend.dWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] / - eps*sign(sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]) - else - quot.eWerte.werte[i+j*quot._xSteps]:= - dend.dWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] / - sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]; - i01:=i01 and (dend.dWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps]=0); - i02:=i02 and (sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]=0); - o0:=o0 and (quot.eWerte.werte[i+j*quot._xSteps]=0); - end; - end; + quot.eWerte.quotioent(pTLLWerteDouble(@dend.dWerte),pTLLWerteExtended(@sor.eWerte),xMi,xMa,xOf,tMi,tMa,tOf,eps); end{of case}; gExtended: case sor.genauigkeit of gSingle: // extended / single - for j:=tMi to tMa do begin - if (tMa-j) mod ((tMa-tMi) div 10) = 0 then - gibAus('Quotient-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1); - for i:=xMi to xMa do - if abs(sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps])<eps then - quot.eWerte.werte[i+j*quot._xSteps]:= - dend.eWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] / - eps*sign(sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]) - else - quot.eWerte.werte[i+j*quot._xSteps]:= - dend.eWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] / - sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]; - i01:=i01 and (dend.eWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps]=0); - i02:=i02 and (sor.sWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]=0); - o0:=o0 and (quot.eWerte.werte[i+j*quot._xSteps]=0); - end; + quot.eWerte.quotioent(pTLLWerteExtended(@dend.eWerte),pTLLWerteSingle(@sor.sWerte),xMi,xMa,xOf,tMi,tMa,tOf,eps); gDouble: // extended / double - for j:=tMi to tMa do begin - if (tMa-j) mod ((tMa-tMi) div 10) = 0 then - gibAus('Quotient-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1); - for i:=xMi to xMa do begin - if abs(sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps])<eps then - quot.eWerte.werte[i+j*quot._xSteps]:= - dend.eWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] / - eps*sign(sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]) - else - quot.eWerte.werte[i+j*quot._xSteps]:= - dend.eWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] / - sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]; - i01:=i01 and (dend.eWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps]=0); - i02:=i02 and (sor.dWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]=0); - o0:=o0 and (quot.eWerte.werte[i+j*quot._xSteps]=0); - end; - end; + quot.eWerte.quotioent(pTLLWerteExtended(@dend.eWerte),pTLLWerteDouble(@sor.dWerte),xMi,xMa,xOf,tMi,tMa,tOf,eps); gExtended: // extended / extended - for j:=tMi to tMa do begin - if (tMa-j) mod ((tMa-tMi) div 10) = 0 then - gibAus('Quotient-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1); - for i:=xMi to xMa do begin - if abs(sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps])<eps then - quot.eWerte.werte[i+j*quot._xSteps]:= - dend.eWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] / - eps*sign(sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]) - else - quot.eWerte.werte[i+j*quot._xSteps]:= - dend.eWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps] / - sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]; - i01:=i01 and (dend.eWerte.werte[(xOf+i) + (tOf+j)*dend._xSteps]=0); - i02:=i02 and (sor.eWerte.werte[(xOf+i) + (tOf+j)*sor._xSteps]=0); - o0:=o0 and (quot.eWerte.werte[i+j*quot._xSteps]=0); - end; - end; + quot.eWerte.quotioent(pTLLWerteExtended(@dend.eWerte),pTLLWerteExtended(@sor.eWerte),xMi,xMa,xOf,tMi,tMa,tOf,eps); end{of case}; end{of Case}; - if i01 then gibAus('Nur Nullen im Dividend-Input!',1); - if i02 then gibAus('Nur Nullen im Divisor-Input!',1); - if o0 then gibAus('Nur Nullen im Output!',1); gibAus('... und fertig!',1); end; // tProduktThread ************************************************************* -constructor tProduktThread.create(faktor1, faktor2, produkt: tWerte; xMin,xMax,tMin,tMax,xOff,tOff: longint); +constructor tProduktThread.create(faktor1, faktor2, produkt: tWerte; xMin,xMax,tMin,tMax,xOff,tOff: longint; datenOrdnung: tFFTDatenordnung; konjugiert: boolean); begin inherited create; f1:=faktor1; @@ -5789,143 +5671,44 @@ begin tMa:=tMax; tOf:=tOff; xOf:=xOff; + daO:=datenOrdnung; + konj:=konjugiert; gibAus('Starte Produkt-Berechnungsthread!',1); suspended:=false; end; procedure tProduktThread.stExecute; -var - i,j: longint; - i01,i02,o0: boolean; begin gibAus('Produkt-Berechnungsthread gestartet ...',1); - i01:=true; - i02:=true; - o0:=true; - case f1.genauigkeit of gSingle: case f2.genauigkeit of gSingle: // single * single - for j:=tMi to tMa do begin - if (tMa-j) mod ((tMa-tMi) div 10) = 0 then - gibAus('Produkt-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1); - for i:=xMi to xMa do - pro.eWerte.werte[i+j*pro._xSteps]:= - f1.sWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps] * - f2.sWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps]; - i01:=i01 and (f1.sWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps]=0); - i02:=i02 and (f2.sWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps]=0); - o0:=o0 and (pro.eWerte.werte[i+j*pro._xSteps]=0); - end; + pro.eWerte.produkt(pTLLWerteSingle(@f1.sWerte),pTLLWerteSingle(@f2.sWerte),xMi,xMa,xOf,tMi,tMa,tOf,konj,daO); gDouble: // single * double - for j:=tMi to tMa do begin - if (tMa-j) mod ((tMa-tMi) div 10) = 0 then - gibAus('Produkt-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1); - for i:=xMi to xMa do - pro.eWerte.werte[i+j*pro._xSteps]:= - f1.sWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps] * - f2.dWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps]; - i01:=i01 and (f1.sWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps]=0); - i02:=i02 and (f2.dWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps]=0); - o0:=o0 and (pro.eWerte.werte[i+j*pro._xSteps]=0); - end; + pro.eWerte.produkt(pTLLWerteSingle(@f1.sWerte),pTLLWerteDouble(@f2.dWerte),xMi,xMa,xOf,tMi,tMa,tOf,konj,daO); gExtended: // single * extended - for j:=tMi to tMa do begin - if (tMa-j) mod ((tMa-tMi) div 10) = 0 then - gibAus('Produkt-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1); - for i:=xMi to xMa do - pro.eWerte.werte[i+j*pro._xSteps]:= - f1.sWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps] * - f2.eWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps]; - i01:=i01 and (f1.sWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps]=0); - i02:=i02 and (f2.eWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps]=0); - o0:=o0 and (pro.eWerte.werte[i+j*pro._xSteps]=0); - end; + pro.eWerte.produkt(pTLLWerteSingle(@f1.sWerte),pTLLWerteExtended(@f2.eWerte),xMi,xMa,xOf,tMi,tMa,tOf,konj,daO); end{of case}; gDouble: case f2.genauigkeit of gSingle: // double * single - for j:=tMi to tMa do begin - if (tMa-j) mod ((tMa-tMi) div 10) = 0 then - gibAus('Produkt-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1); - for i:=xMi to xMa do - pro.eWerte.werte[i+j*pro._xSteps]:= - f1.dWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps] * - f2.sWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps]; - i01:=i01 and (f1.dWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps]=0); - i02:=i02 and (f2.sWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps]=0); - o0:=o0 and (pro.eWerte.werte[i+j*pro._xSteps]=0); - end; + pro.eWerte.produkt(pTLLWerteDouble(@f1.dWerte),pTLLWerteSingle(@f2.sWerte),xMi,xMa,xOf,tMi,tMa,tOf,konj,daO); gDouble: // double * double - for j:=tMi to tMa do begin - if (tMa-j) mod ((tMa-tMi) div 10) = 0 then - gibAus('Produkt-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1); - for i:=xMi to xMa do - pro.eWerte.werte[i+j*pro._xSteps]:= - f1.dWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps] * - f2.dWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps]; - i01:=i01 and (f1.dWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps]=0); - i02:=i02 and (f2.dWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps]=0); - o0:=o0 and (pro.eWerte.werte[i+j*pro._xSteps]=0); - end; + pro.eWerte.produkt(pTLLWerteDouble(@f1.dWerte),pTLLWerteDouble(@f2.dWerte),xMi,xMa,xOf,tMi,tMa,tOf,konj,daO); gExtended: // double * extended - for j:=tMi to tMa do begin - if (tMa-j) mod ((tMa-tMi) div 10) = 0 then - gibAus('Produkt-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1); - for i:=xMi to xMa do - pro.eWerte.werte[i+j*pro._xSteps]:= - f1.dWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps] * - f2.eWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps]; - i01:=i01 and (f1.dWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps]=0); - i02:=i02 and (f2.eWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps]=0); - o0:=o0 and (pro.eWerte.werte[i+j*pro._xSteps]=0); - end; + pro.eWerte.produkt(pTLLWerteDouble(@f1.dWerte),pTLLWerteExtended(@f2.eWerte),xMi,xMa,xOf,tMi,tMa,tOf,konj,daO); end{of case}; gExtended: case f2.genauigkeit of gSingle: // extended * single - for j:=tMi to tMa do begin - if (tMa-j) mod ((tMa-tMi) div 10) = 0 then - gibAus('Produkt-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1); - for i:=xMi to xMa do - pro.eWerte.werte[i+j*pro._xSteps]:= - f1.eWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps] * - f2.sWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps]; - i01:=i01 and (f1.eWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps]=0); - i02:=i02 and (f2.sWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps]=0); - o0:=o0 and (pro.eWerte.werte[i+j*pro._xSteps]=0); - end; + pro.eWerte.produkt(pTLLWerteExtended(@f1.eWerte),pTLLWerteSingle(@f2.sWerte),xMi,xMa,xOf,tMi,tMa,tOf,konj,daO); gDouble: // extended * double - for j:=tMi to tMa do begin - if (tMa-j) mod ((tMa-tMi) div 10) = 0 then - gibAus('Produkt-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1); - for i:=xMi to xMa do - pro.eWerte.werte[i+j*pro._xSteps]:= - f1.eWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps] * - f2.dWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps]; - i01:=i01 and (f1.eWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps]=0); - i02:=i02 and (f2.dWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps]=0); - o0:=o0 and (pro.eWerte.werte[i+j*pro._xSteps]=0); - end; + pro.eWerte.produkt(pTLLWerteExtended(@f1.eWerte),pTLLWerteDouble(@f2.dWerte),xMi,xMa,xOf,tMi,tMa,tOf,konj,daO); gExtended: // extended * extended - for j:=tMi to tMa do begin - if (tMa-j) mod ((tMa-tMi) div 10) = 0 then - gibAus('Produkt-Berechnungsthread: '+intToStr(j)+'/'+intToStr(tMi)+'..'+intToStr(tMa)+' ('+intToStr(xMi)+'..'+intToStr(xMa)+')',1); - for i:=xMi to xMa do - pro.eWerte.werte[i+j*pro._xSteps]:= - f1.eWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps] * - f2.eWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps]; - i01:=i01 and (f1.eWerte.werte[(xOf+i) + (tOf+j)*f1._xSteps]=0); - i02:=i02 and (f2.eWerte.werte[(xOf+i) + (tOf+j)*f2._xSteps]=0); - o0:=o0 and (pro.eWerte.werte[i+j*pro._xSteps]=0); - end; + pro.eWerte.produkt(pTLLWerteExtended(@f1.eWerte),pTLLWerteExtended(@f2.eWerte),xMi,xMa,xOf,tMi,tMa,tOf,konj,daO); end{of case}; end{of Case}; - - if i01 then gibAus('Nur Nullen im 1.Faktor-Input!',1); - if i02 then gibAus('Nur Nullen im 2.Faktor-Input!',1); - if o0 then gibAus('Nur Nullen im Output!',1); gibAus('... und fertig!',1); end; |