Logarithmus Log zu Delphi

[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

[EWeiss]

Zitat:

Zitat von Klaus01 (Beitrag 1428129)

.. 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

[Klaus01]

Zitat:

Zitat von Sherlock (Beitrag 1428130)

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

Delphi-Quellcode:

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:

Zitat von Klaus01 (Beitrag 1428132)

Zitat:

Zitat von Sherlock (Beitrag 1428130)

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

Delphi-Quellcode:

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

[Sherlock]

Stimmt, und das ist nach dem ln.

Also muß man prüfen, ob da Extremwerte rauskommen, die der ln nicht verkraftet. Leider ist die Doku da sehr dünn, und ich habe vom ln an sich zu wenig Ahnung.

Sherlock

[Klaus01]

.. wie groß können denn Spectrum[i1].r und Spectrum[i1].i maximal werden?

wenn die gegen 0 gehen wird der ln von .0001 gebildet -> -9.2103403719761827360719658187375

Grüße
Klaus

[EWeiss]

Zitat:

Zitat von Sherlock (Beitrag 1428134)

Stimmt, und das ist nach dem ln.
und ich habe vom ln an sich zu wenig Ahnung.

Sherlock

Mir geht's genauso..
Fand das Original nicht schlecht und wollte es halt mal nach Delphi umsetzen (Nebenbei Vaporware ist das nicht) zu viel Aufwand wie man sehen kann.
Und man kann von lernen. ;)

Mein Hauptproblem zur zeit ist das der Linker mich einfach rausschmeißt.

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; stdcall;
 begin
   if doubleVal > MaxSingle then
     result := MaxSingle
   else if doubleVal < MinSingle then
     result := MinSingle
   else
     result := doubleVal;
 end;

begin

Der linker entfernt variablen.

Delphi-Quellcode:

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

hier FFFTSize.

EurekaLog springt dann mit einem Access Violation auf das letzte end im oberen Quelltext. Mit der Meldung vom Speicher kann nicht gelesen werden.
Da ist einiges im argen.

Zitat:

.. wie groß können denn Spectrum[i1].r und Spectrum[i1].i maximal werden?

Kann ich leider mit Bestimmtheit nicht sagen.

Wenn Interesse besteht kann ich den Quelltext zum debuggen aber gerne mal hochladen.
Oder ich schicke einen Link per PN.

gruss

[Delphi.Narium]

Nur 'ne blöde Idee, ein Schuss ins Blaue:

Mach' bitte mal aus

Delphi-Quellcode:

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

dashier:

Delphi-Quellcode:

  mGain := (FGain / 100);
  sr := IfThen(FView = 0, 4096 * mGain, 1) / FFFTSize;

Geht das und ändert sich dann was?

[EWeiss]

Delphi-Quellcode:

IfThen(FView = 0, (4096 * mGain) / FFFTSize, 1);

Ist am ende das gleiche oder?

Das Ergebnis ist das gleiche.
Habe es versucht. Danke.

gruss

[Delphi.Narium]

nicht ganz:
entweder

Delphi-Quellcode:

IfThen(FView = 0, (4096 * mGain) / FFFTSize, 1 / FFFTSize);

oder

Delphi-Quellcode:

IfThen(FView = 0, (4096 * mGain), 1)  / FFFTSize;

Im ursprünglichen Quelltext findet für sr ja auch im Else noch eine Division durch FFFTSize statt, muss also im IfThen entweder in beiden Fällen durchgeführt werden oder auf das Ergebnis von IfThen.