produkt kann jetzt auch komplex konjugiert multiplizieren; produkt und quotient in werteunit.inc ausgelagert

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;