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