void reset(double r1, double i1,ComplexNumber&a, ComplexNumber&c)
{
a.setReal(r1);
a.setImag(i1);
c.setReal(0);
c.setImag(0);
};
ComplexNumber ComplexNumber::operator +(const ComplexNumber& other)
{
ComplexNumber c;
c.real = getReal() + other.getReal();
c.imag = getImag() + other.getImag();
return c;
}
ComplexNumber ComplexNumber::operator*(const ComplexNumber& z) const
{
return ComplexNumber(mRealPart * z.GetRealPart()
- mImaginaryPart * z.GetImaginaryPart(),
mImaginaryPart * z.GetRealPart()
+ mRealPart * z.GetImaginaryPart());
}
bool ComplexNumber::operator <(ComplexNumber& other)
{
if(getReal() < other.getReal())
return true;
else if(getReal() == other.getReal())
return (getImag() < other.getImag());
}
TEST(Zhiltsov_Max_ComplexNumberTest, LimitingValueAddition_Correct) {
const ComplexNumber z(std::numeric_limits<double>::max(), 0);
ComplexNumber sum = z + z;
EXPECT_TRUE(std::isinf(sum.getRe()));
}
TEST(Zhiltsov_Max_ComplexNumberTest, Multiplication_Correct) {
const ComplexNumber z1(1.0e100, 0);
const ComplexNumber z2(2.0, 0);
ComplexNumber result = z1 * z2;
EXPECT_DOUBLE_EQ(2.0e100, result.getRe());
}
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;
}
// Override.
// ln(z) = ln(|r|) + i * theta, where z = r * e^(i * theta)
// log_z(w) = ln(w) * log_z(e) = ln(w) * 1 / (ln(r) + i * theta), where z = r * e^(i * theta).
ComplexNumber Logarithm::eval(const ComplexNumber z) const {
ComplexNumber argument = z + lambda;
ComplexNumber ln_z (log(argument.mag()), argument.angle());
if (base == exp(1)) {
return coefficient * ln_z;
} else {
ComplexNumber one (1, 0);
ComplexNumber log_base (log(base.mag()), base.angle());
return coefficient * ln_z * (one / log_base);
}
}
ComplexNumber operator*( ComplexNumber& first, ComplexNumber& second) {
ComplexNumber c;
double newRe=(first.Re()*second.Re())-(first.Im()*second.Im());
double newIm=(first.Re()*second.Im())+(first.Im()*second.Re());
c.setRe(newRe);
c.setIm(newIm);
return c;
}
int main(){
long real1,imaginary1,real2,imaginary2;
scanf("%ld%ld",&real1,&imaginary1);
ComplexNumber a={real1,imaginary1};
scanf("%ld%ld",&real2,&imaginary2);
ComplexNumber b={real2,imaginary2};
ComplexNumber c;
c.saberi(a,b);
c.oduzmi(a,b);
c.pomnozi(a,b);
c.podeli(a,b);
return 0;
}
TEST(Zhiltsov_Max_ComplexNumberTest, DISABLED_LimitingValueAddition_Incorrect) {
const ComplexNumber z1(std::numeric_limits<double>::max(), 0);
const ComplexNumber z2(1.0, 0.0);
ComplexNumber sum = z1 + z2;
/*
Failure because of IEEE754 floating point format and
addition algorithm in particular.
Expected result is at least "+inf" value
instead of the same value as bigger operand.
Possible solution:
a) try to use a safe arihmetics algorithms
b) throw an expection
*/
EXPECT_TRUE(std::isinf(sum.getRe()));
}
ComplexNumber operator+(ComplexNumber& first, ComplexNumber& second) {
ComplexNumber c;
c.setRe(first.Re()+second.Re());
c.setIm(first.Im()+second.Im());
return c;
}
//
// 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::ComplexNumber(const ComplexNumber& orig) {
setAll(orig.getReal(), orig.m_imag);
}
ComplexNumber ComplexNumber::add(const ComplexNumber& c1,const ComplexNumber& c2){
//std::cout << __PRETTY_FUNCTION__ << std::endl;
ComplexNumber sum = c1;
sum.add(c2);
return sum;
}
bool operator==(const ComplexNumber& c1, const ComplexNumber& c2){
if ((c1.Real()==c2.Real())&(c1.Imag()==c2.Imag())) return true;
return false;
}
// Checking if not Equal
bool operator!=(const ComplexNumber & lhs, const ComplexNumber & rhs) {
if(lhs.equals(rhs)) return false;
return true;
}
T modulusSquared(const ComplexNumber<T>& z)
{
return 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
}
ComplexNumber operator-(const ComplexNumber& first, const ComplexNumber& second) {
return ComplexNumber(first.getReal() - second.getReal(),
first.getImag() - second.getImag());
}
T modulus(const ComplexNumber<T>& z)
{
return std::sqrt(z.real() * z.real() + z.imag() * z.imag());
}
bool operator<(const ComplexNumber& first, const ComplexNumber& second) {
return sqrt(pow(first.getReal(), 2) + pow(first.getImag(), 2))
< sqrt(pow(second.getReal(), 2) + pow(second.getImag(), 2));
}
inline ComplexNumber<T>& ComplexNumber<T>::operator-=(const ComplexNumber& z)
{
re_ -= z.real();
im_ -= z.imag();
return *this;
}
void ExtractDescriptorHelper::extractFourierDescriptors(CvSeq* contour)
{
int x=contour->total;
CvPoint *pt=new CvPoint[contour->total];
for(int i=0; i<contour->total; i++)
{
pt[i] = *(CvPoint*)cvGetSeqElem(contour, i);
//cout<<"x:"<< pt[i].x<<" y:"<<pt[i].y<<endl;
}
//cout<<"Koordinatlar yazildi"<<endl;
vector<ComplexNumber> contoursComplex; //Complex Number vectoru olusturduk
int r1, i1;
for(int j=0; j<contour->total; j++) // contour kordinatlarýný vectorde karmaþýk olarak tuttuk 1+2j gibi
{
ComplexNumber temp(pt[j].x, pt[j].y);
//temp.print();
contoursComplex.push_back(temp);
// copy constructor ve assignment operator implemente et çünkü push_back bunlarý kullanýyor. Ve destructor.
}
//contoursComplex ile chainCode u hesapla...
//<Shifting the contour coordinates to center>
ComplexNumber shiftC;
ComplexNumber total(0,0);
for(int x=0; x<contour->total; x++)
{
total=total.add(contoursComplex[x]);
}
ComplexNumber divisor(contour->total, 0);
shiftC=total.div(divisor);
vector<ComplexNumber> T;
for(int x=0; x<contour->total; x++)
{
ComplexNumber tmp;
tmp=contoursComplex[x].sub(shiftC);
T.push_back(tmp);
//T.at(x)=tmp;
}
//</Shifting the contour coordinates to center>
//BURAYA KADAR TRANSITION OLAYI HALLOLDU, BÜTÜN NOKTALAR SANAL BÝR ORJÝNE GÖRE ALINDI.
sortComplexVector(T);// açýlara gore sýralamayý yapýyor. Ufak tefek sapmalar var, elle yazmak yerine quicksort falan yap.
//FFT KISMINI BURADA YAPIYORUM, MATEMATIKSEL ISLEMLERE GORE. DFT nin MATEMATIKSEL TANIMINA BAKILARAK BURADAKI ISLEM ANLASILABILIR
ComplexNumber tempSum;
vector<ComplexNumber> fourierDesc;
ComplexNumber div(T.size(), 0);
for(int u=0; u<T.size(); u++)
{
tempSum.setReal(0);
tempSum.setImag(0);
for(int k=0; k<T.size(); k++)
{
ComplexNumber tempComplex(cos((2*360*u*k*PI)/(180*T.size())), (-1)*(sin((2*360*u*k*PI)/(T.size()*180))));
tempSum=tempSum.add((T.at(k)).mult(tempComplex));
}
fourierDesc.push_back((tempSum.div(div)));
}
//FFT KISMI BURADA BITIYOR
// NORMALIZATION KISMI YAPILIYOR BURADA, SCALE ,TRANSITION VE ROTATION INVARIANT OLUYOR BOYLECE
vector<ComplexNumber> tmpFourierDesc;
for(int i=0; i<fourierDesc.size(); i++)
tmpFourierDesc.push_back(fourierDesc.at(i));
ComplexNumber zero(0,0);
//Translation Invariance:
tmpFourierDesc.at(0)=zero;
//si=abs(T(1)) sayisini tutuyorum
//Scale Invariance:
ComplexNumber myVarSiDiv(sqrt(pow(tmpFourierDesc.at(1).getReal(),2) + pow(tmpFourierDesc.at(1).getImag(),2)), 0);
//T(i)=T(i)/si iþlemi yapýlýyor.
for(int m=0; m<tmpFourierDesc.size(); m++)
tmpFourierDesc.at(m).div(myVarSiDiv);
//Son olarak tum elemanlarý double vectorunde tutuyorum. Boylece fourier desc lar cýktý.
//vector<double> finalFourierDesc;
//Burada da T=abs(T) yi fourier descriptor olarak tuttum, böylece ROTATION AND CHANGES IN STARTING POINT oldu.
//myFourierDescriptors vectoru, class içinde tuttuðum en sonki fourier descriptorlarý içeren vectordur.
for(int n=0; n<tmpFourierDesc.size(); n++)
{
myFourierDescriptors.push_back(sqrt(pow(tmpFourierDesc.at(n).getReal(),2) + pow(tmpFourierDesc.at(n).getImag(),2)));
//cout<<n<<". element: "<<myFourierDescriptors.at(n)<<endl;
}
/*
if(tmpFourierDesc.size()<fourierSize)
{
int substruct=fourierSize-tmpFourierDesc.size();
for(int j=0; j<substruct; j++)
myFourierDescriptors.push_back(0);
}*/
};
// Copy constructor
ComplexNumber::ComplexNumber(const ComplexNumber& c)
: mRealPart(c.GetRealPart()),
mImaginaryPart(c.GetImaginaryPart())
{}
ComplexNumber operator+(const ComplexNumber& c1){
return ComplexNumber (c1.Real(),c1.Imag());
}
