//
// re-calculate frequency response
//
void Plot::setDamp( double damping )
{
const bool doReplot = autoReplot();
setAutoReplot( false );
const int ArraySize = 200;
double frequency[ArraySize];
double amplitude[ArraySize];
double phase[ArraySize];
// build frequency vector with logarithmic division
logSpace( frequency, ArraySize, 0.01, 100 );
int i3 = 1;
double fmax = 1;
double amax = -1000.0;
for ( int i = 0; i < ArraySize; i++ )
{
double f = frequency[i];
const ComplexNumber g =
ComplexNumber( 1.0 ) / ComplexNumber( 1.0 - f * f, 2.0 * damping * f );
amplitude[i] = 20.0 * log10( qSqrt( g.real() * g.real() + g.imag() * g.imag() ) );
phase[i] = qAtan2( g.imag(), g.real() ) * ( 180.0 / M_PI );
if ( ( i3 <= 1 ) && ( amplitude[i] < -3.0 ) )
i3 = i;
if ( amplitude[i] > amax )
{
amax = amplitude[i];
fmax = frequency[i];
}
}
double f3 = frequency[i3] - ( frequency[i3] - frequency[i3 - 1] )
/ ( amplitude[i3] - amplitude[i3 -1] ) * ( amplitude[i3] + 3 );
showPeak( fmax, amax );
show3dB( f3 );
showData( frequency, amplitude, phase, ArraySize );
setAutoReplot( doReplot );
replot();
}
ComplexNumber Exponential::eval(const ComplexNumber z) const {
ComplexNumber exponent = lambda * z;
double exp_re = exp(exponent.real()) * cos(exponent.imag());
double exp_im = exp(exponent.real()) * sin(exponent.imag());
ComplexNumber w (exp_re, exp_im);
return coefficient * w;
}
// Override.
// (r * exp(i * theta))^(a + bi) = r^(a + bi) * exp(i * theta * a - theta * b)
// = (r^a * exp(-theta * b)) * (r^b * exp(theta * a))^i
ComplexNumber Power::eval(const ComplexNumber z) const {
double r = z.mag(), theta = z.angle();
double a = exponent.real(), b = exponent.imag();
double coeff = pow(r, a) * exp(-theta * b);
ComplexNumber w = iPower(pow(r, b) * exp(theta * a));
ComplexNumber v (coeff * w.real(), coeff * w.imag());
return v;
}
inline ComplexNumber<T>& ComplexNumber<T>::operator-=(const ComplexNumber& z)
{
re_ -= z.real();
im_ -= z.imag();
return *this;
}
T modulusSquared(const ComplexNumber<T>& z)
{
return z.real() * z.real() + z.imag() * z.imag();
}
T modulus(const ComplexNumber<T>& z)
{
return std::sqrt(z.real() * z.real() + z.imag() * z.imag());
}
bool operator==(const ComplexNumber<T>& a, const ComplexNumber<T>& b) // equal
{
return a.real() == b.real() && a.imag() == b.imag();
}
ComplexNumber<T> operator-(const ComplexNumber<T>& a)
{
return {-a.real(), -a.imag()}; // unary minus
}
