Logarithmus Log zu Delphi

[Klaus01]

sqr in Visual basic -> Square root , also Quadrat Wurzel

sqr in Delphi -> Square -> Quadratzahl

sqrt in Delphi -> Square root

Quelle: http://www.vbforums.com/showthread.p...9-Sqr-And-Sqrt

Grüße
Klaus

[EWeiss]

Zitat von Klaus01:

sqr in Visual basic -> Square root , also Quadrat Wurzel

sqr in Delphi -> Square -> Quadratzahl

sqrt in Delphi -> Square root

Quelle: http://www.vbforums.com/showthread.p...9-Sqr-And-Sqrt

Grüße
Klaus

Ahhh dann ist sqr definitiv schon mal falsch.
Was ist mit LN?

Danke!

gruss

[Klaus01]

Zitat von EWeiss:

Was ist mit LN?

Danke!

gruss

..sollte passen.

https://docs.microsoft.com/en-us/dot...ystem.math.log

In Delphi code, Ln returns the natural logarithm (Ln(e) = 1) of the real-type expression X.



Grüße
Klaus

[Sherlock]

Welcher Logarithmus ist hier erwünscht? Das Log im VB-Beispiel ist gemäß Doku der natürliche (also Basis e). Der Delphi Log ist der dekadische (Basis 10). Korrekt wäre System.Ln.

Sherlock

[EWeiss]

Zitat von Sherlock:

Welcher Logarithmus ist hier erwünscht? Das Log im VB-Beispiel ist gemäß Doku der natürliche (also Basis e). Der Delphi Log ist der dekadische (Basis 10). Korrekt wäre System.Ln.

Sherlock

Jo und den verwende ich System.LN. Danke.
Leider habe ich trotzdem das Problem mit -NAN obwohl ich schon den Überlauf prüfe.

Delphi-Quellcode:

 function LimitedSingleValue(doubleVal: double): single;
 begin
   if doubleVal > MaxSingle then
     result := MaxSingle
   else if doubleVal < MinSingle then
     result := MinSingle
   else
     result := doubleVal;
 end;

Schlage mich damit jetzt schon ein paar Tage mit rum.
Also wenn an doubleVal der wert -NAN ankommt dann kracht es trotzdem.

Zitat:

..sollte passen.

Danke Klaus.

gruss

[Klaus01]

.. du könntest zusätzlich auf isNAN testen.

Grüße
Klaus

[EWeiss]

Zitat von Klaus01:

.. du könntest zusätzlich auf isNAN testen.

Grüße
Klaus

Das habe ich schon versucht.

Zitat:

Eventuell führst Du nicht alles in einem Schritt durch, sondern ziehst erst die Wurzel und schaust, ob da ein "ln-taugliches" Ergebnis raus kommt (zumindest mal positiv).

Hier ist mal der Algo..

Delphi-Quellcode:

procedure TSpectrum.FFT(Dat: array of TComplex);
var
  i, j, n, K , io, ie, in_, nn: Integer;
  u, tp, tq, w: TComplex;
  sr, mGain: Single;

 function LimitedSingleValue(doubleVal: double): single;
 begin
   if doubleVal > MaxSingle then
     result := MaxSingle
   else if doubleVal < MinSingle then
     result := MinSingle
   else
     result := doubleVal;
 end;

begin

  if not FFTInit then
  begin
    InitFFT;
    FFTInit := True;
  end;

  nn := FFFTSize div 2;
  ie := FFFTSize;
  for n := 1 to FFTLog do
  begin
    w := Coef[FFTLog - n];
    in_ := ie div 2;
    u.r := 1;
    u.i := 0;

    for j := 0 to (in_ - 1) do
    begin
      for i := j to (FFFTSize - 1) do
      begin
        if i mod ie <> 0 then
          continue;

        io := i + in_;

        if (i >= (FFFTSize - 1)) or (io >= (FFFTSize - 1)) then
          continue;

        tp.r := LimitedSingleValue(Dat[i].r + Dat[io].r);
        tp.i := LimitedSingleValue(Dat[i].i + Dat[io].i);

        tq.r := Dat[i].r - Dat[io].r;
        tq.i := Dat[i].i - Dat[io].i;

        Dat[io].r := tq.r * u.r - tq.i * u.i;
        Dat[io].i := LimitedSingleValue(tq.i * u.r + tq.r * u.i);
        Dat[i] := tp;
      end;
      sr := u.r;
      u.r := u.r * w.r - u.i * w.i;
      u.i := u.i * w.r + sr * w.i;
    end;
    ie := ie div 2;
  end;

  j := 1;
  for i := 1 to (FFFTSize - 1) do
  begin
    if i < j then
    begin
      io := i - 1;
      in_ := j - 1;
      tp := Dat[in_];
      Dat[in_] := Dat[io];
      Dat[io] := tp;
    end;

    K := nn;
    While K < j do
    begin
      j := j - K;
      K := K div 2;
    end;
    j := j + K;
  end;

  mGain :=  (FGain / 100);
  if FView = 0 then
    sr := (4096 * mGain) / FFFTSize
  else
  sr := 1 / FFFTSize;

  for i := 0 to (FFFTSize div 2) - 1 do
  begin
    Dat[i].r := Dat[i].r * sr;
    Dat[i].i := Dat[i].i * sr;
  end;
end;

gruss

[Sherlock]

Eventuell führst Du nicht alles in einem Schritt durch, sondern ziehst erst die Wurzel und schaust, ob da ein "ln-taugliches" Ergebnis raus kommt (zumindest mal positiv).

Sherlock

[Klaus01]

Zitat von Sherlock:

Eventuell führst Du nicht alles in einem Schritt durch, sondern ziehst erst die Wurzel und schaust, ob da ein "ln-taugliches" Ergebnis raus kommt (zumindest mal positiv).

Sherlock

b := (LN(Sqrt(sqr(Spectrum[i1].r) + sqr(Spectrum[i1].i)) + 0.0001) + 9.21034037197618) * q1;
In Prinzip kann das ganze nur negativ werden wenn q1 < 0 ist.
LN bekommt immer ein positiven Wert gebildet aus: sqrt(sqr(Spectrum[i1].r) + sqr(Spectrum[i1].i)) + 0.0001

Grüße
Klaus

[EWeiss]

Zitat von Klaus01:

Zitat von Sherlock:

Eventuell führst Du nicht alles in einem Schritt durch, sondern ziehst erst die Wurzel und schaust, ob da ein "ln-taugliches" Ergebnis raus kommt (zumindest mal positiv).

Sherlock

b := (LN(Sqrt(sqr(Spectrum[i1].r) + sqr(Spectrum[i1].i)) + 0.0001) + 9.21034037197618) * q1; In Prinzip kann das ganze nur negativ werden wenn q1 < 0 ist.

Grüße
Klaus

q1 kann keinen negativen wert bekommen.

Delphi-Quellcode:

  i1 := 1;
  q2 := 0;
  q1 := 0;

  case View of

    0:
      begin
        for o := 0 to FOctaveCount - 1 do
        begin
          fl := True;
          q2 := q2 + OctAreaSize;

          i2 := i1 * 2;
          While i1 < i2 do
          begin
            b := round(Sqrt(Spectrum[i1].r * Spectrum[i1].r + Spectrum[i1].i * Spectrum[i1].i));
            if b > 255 then
              b := 255;

            GDIP_SetPenColor(Pen, Palette[round(b)]);

            if MapData[i1].IsLine then
            begin
              if not fl then
              begin
                GDIP_SetPenWidth(Pen, 1);

                fl := True;
                q1 := q1 + 4;
                q2 := q2 + 2;

               GDIP_DrawLine(grSpectrum, Pen, MapData[i1].fa * q1 + Sw,
                 MapData[i1].ta * q1 + Sh, MapData[i1].fa * q2 + Sw,
                 MapData[i1].ta * q2 + Sh);
              end;
            end else
              begin
                if fl then
                begin
                  GDIP_SetPenWidth(Pen, OctAreaSize - 2);
                  fl := False;

                  GDIP_DrawArc(grSpectrum, Pen, Sw - q2, Sh - q2, q2 * 2 - 1, q2 * 2 - 1,
                    MapData[i1].fa, MapData[i1].ta);
                end;
              end;
              i1 := i1 + 1;
          end;
          q1 := q1 + OctAreaSize;
        end;
      end;

gruss