C++ Complex Typ nach Pascal

[totti14]

Hallöchen,
Ich habe eine kleine c++ lib die ich gerade Delphi konvertiere.
Jetzt hänge ich leider an diesen Typ Complex ?
response.real oder imag = 1234 das verstehe ich ja noch
aber response = 10+10+10 ??
Kann mir da jemand helfen wie ich das in Pascal lösen kann ?
Da gibt es ja die JCLComplex.
Vielen Dank schonmal
Totti

Code:

void BIQUAD::GetFrqResponse(f64 &module_dB, f64 &phase_degree, f64 f_Hz)
{
complex response;
double omega;

omega = 2.0*PI*f_Hz/fs;

complex z1(cos(omega),sin(omega));         // Z^(-1)
complex z2(cos(2.0*omega),sin(2.0*omega)); // Z^(-2)


response = (b0 + (b1*z1) + (b2*z2))/(1.0 + (a1*z1) + (a2*z2));

module_dB       = 20.0*log10(sqrt(srd(response.real()) + srd(response.imag())));
phase_degree    = (180.0/PI)*atan2(response.imag(),response.real()); 
}

[hoika]

Hallo,

das ist ein constructor-Aufruf

mit
response =
wird ein constructor aufgerufen, der nur real setzt (imag wird auf 0 gesetzt.

siehe http://support.sas.com/documentation...s/z0274855.htm
dort die Zeile c3=10; // c3 is (10.0, 0.0).


Heiko

[sniper_w]

Delphi-Quellcode:

function AddComplex( z1, z2: complex ): complex;
begin
// wie man das macht, weiss ich jetzt nicht, sollte/dürfte gar nicht so schwer sein
// einfach die c++ implemetation anschauen und übersetzen
end;

function MulComplex( z1, z2: complex ): complex;
begin
// wie man das macht, weiss ich jetzt nicht, sollte/dürfte gar nicht so schwer sein
// einfach die c++ implemetation anschauen und übersetzen
end;

function DivComplex( z1, z2: complex ): complex;
begin
// wie man das macht, weiss ich jetzt nicht, sollte/dürfte gar nicht so schwer sein
// einfach die c++ implemetation anschauen und übersetzen
end;

procedure BIQUAD.GetFrqResponse(var module_dB, phase_degree:f64; f_Hz:f64 );
var
  response, z1, z2: complex;
  omega: double;
begin
  omega := 2.0 * PI *f_Hz / fs;

  z1.real_ := cos(omega);
  z1.imag := sin(omega);         // Z^(-1)
  
  
  z2.real_ := cos(2.0 * omega);
  z2.imag := sin(2.0 * omega);         // Z^(-2)
  
  // response = (b0 + (b1*z1) + (b2*z2))/(1.0 + (a1*z1) + (a2*z2));
  
  // um response zu kalkulieren muss man wissen wie man imaginere zahlen addiert,
  // multipliziert und dividiert
  // in c++ implementiert man operator overloading, was in füheren Delphi versionen
  // nicht  geht, so dass man dies über die entsprechenden funktionen machen muss
  
  // noch was , statt ??? musst du herausfinden wie man 1 in komplexzahlen ausdruckt
  // dies sollet nicht schwierig sein
  
  response := AddComplex( b0 , AddComplex( MulComplex(b1, z1) , DivComplex( MulComplex(b2, z2) , 
      AddComplex( ??? , AddComplex( MulComplex(a1, z1) , MulComplex(a2, z2)) ) ) )  );

  module_dB       := 20.0 * log10(sqrt(srd(response.real_) + srd(response.imag)));
  phase_degree    := (180.0 / PI) * atan2( response.imag ,response.real_);
  
end;

[totti14]

Danke,
das sieht ja schon sehr gut aus ist ja auch ein hartes brot für einen dussligen autolackierer. :lol:
das werde ich heute abend mal probieren wenn mein kleiner im bett ist.

totti14

[totti14]

So funzt es mit den overloaded operatoren von D2006 und der Math386 von Dew Research.

Delphi-Quellcode:

// b0, b1, b2, a1, a2: f64;            //internal biquad unquantized coeffs
procedure TBIQUAD.GetFrqResponse(&module_dB: f64; &phase_degree: f64; f_Hz: f64);
var response, z1, z2  : TCplx;
    omega             : TSample;
begin
  omega := 2 * PI * f_Hz / fs;

  SinCos(omega, z1.Im, z1.Re);
  SinCos(2 * omega, z2.Im, z2.Re);

  response := (b0 + (b1 * z1) + (b2 * z2)) / (1 + (a1 * z1) + (a2 * z2));

  module_dB := 20 * Log10(CAbs(response));
  phase_degree := (180 / PI) * Arg(response);
end;