Treba da isprogramiram proračun nekog elektroenergetskog sistema, tzv. problem "tokova snaga". Za to mi treba račun sa matricama kompleksnih brojeva. Napisao sam klase Complex i Matrica u kojima je kompleksni i matrični račun implementiran i preklopljeni aritmetički operatori, ali kad hoću da primenim te operatore u npr. klasi Transformator, javljaju se problemi. Evo klase Complex:
#include <math.h>
inline double sqr (double x) {return x * x;}
class complex
{
public:
double re, im;
complex ( ) { }
complex ( double r, double i=0.0) : re(r), im(i) { }
complex operator + () const
{ return *this; }
complex operator - () const
{return complex (-re, -im); }
friend complex operator + ( const complex &left, const complex &right)
{ return complex (left.re+right.re, left.im+right.im);}
friend complex operator - (const complex &left, const complex &right)
{ return complex (left.re+right.re, left.im+right.im);}
friend complex operator * (const complex &left, const complex &right)
{
return complex (left.re*right.re-left.im*right.im, left.re*right.im+right.re*left.im);
}
friend complex operator / (const complex &left, const complex &right)
{
double r= sqr(right.re)+sqr(right.im);
return complex ((left.re*right.re+left.im*right.im)/r, (right.re*left.im-left.re*right.im)/r);
}
complex & operator += (const complex &c)
{
re+=c.re;
im+=c.im;
return *this;
}
complex & operator -= (const complex &c)
{
re-=c.re;
im-=c.im;
return *this;
}
complex & operator *= (const complex &c)
{ return *this=*this*c; }
complex & operator /= (const complex &c)
{ return *this=*this/c; }
friend bool operator == (const complex &left, const complex &right)
{ return left.re == right.re && left.im==right.im;}
friend bool operator != (const complex &left, const complex &right)
{ return left.re != right.re || left.im!=right.im;}
friend complex conjug (const complex & c)
{ return complex (c.re, -c.im);}
friend double abs (const complex &c)
{ return sqrt ( sqr(c.re)+sqr(c.im));}
friend double arg (const complex & c)
{ return atan2 (c.im, c.re);}
friend std::ostream & operator << (std::ostream &os, const complex &c)
{ return os << c.re << "+ j" << c.im;}
friend std::istream & operator >> (std::istream &is, const complex &c)
{return is >> c.re >> c.im; }
};
#endif //__COMPLEX_H
Klasa Matrica:
#ifndef __MATRICA_H
#define __MATRICA_H
#include <iostream>
#include <math.h>
#include "complex.hpp"
class matrica
{
private:
complex A[3][3];
public:
complex B[3][3];
matrica ( ) { }
matrica ( complex B[3][3] ) : B(A) { }
complex& operator () (int sklj, int mlj)
{
complex E[3][3];
return E[sklj][mlj];
}
matrica operator + () const
{ return *this; }
matrica operator - (matrica &C) const
{
complex D[3][3];
for (int i=0; i<3; i++)
{
for (int j=0;j<3;j++)
{
D[i][j]=-C(i,j);
}
}
matrica H=matrica(D);
return H;
}
friend matrica operator+ ( matrica& E, matrica& F)
{
complex G[3][3];
for (int i=0;i<3;i++)
{
for (int j=0; j<3; j++)
{
G[i][j]=E(i,j)+F(i,j);
}
}
matrica H=matrica(G);
return matrica(G);
}
friend matrica operator- ( matrica& E, matrica& F)
{
complex G[3][3];
for (int i=0;i<3;i++)
{
for (int j=0; j<3; j++)
{
G[i][j]=E(i,j)-F(i,j);
}
}
matrica H=matrica(G);
return H;
}
friend matrica operator* ( matrica& E, matrica& F)
{
complex G[3][3];
for(int i=0;i<3;i++)
{
for(int k=0;k<3;k++)
{
complex m=0;
for(int j=0;j<3;j++)
{
m+=E(i,j)*F(j,k);
}
G[i][k]=m;
}
}
matrica H=matrica(G);
return H;
}
friend matrica inv(matrica &C)
{
complex D[3][3];
complex adj[3][3];
adj[0][0]=C(1,1)*C(2,2)-C(2,1)*C(1,2);
adj[0][1]=C(2,0)*C(1,2)-C(1,0)*C(2,2);
adj[0][2]=C(1,0)*C(2,1)-C(1,1)*C(2,0);
adj[1][0]=C(0,2)*C(2,1)-C(0,1)*C(2,2);
adj[1][1]=C(0,0)*C(2,2)-C(2,0)*C(0,2);
adj[1][2]=C(2,0)*C(0,1)-C(0,0)*C(2,1);
adj[2][0]=C(0,1)*C(1,2)-C(1,1)*C(0,2);
adj[2][1]=C(1,0)*C(0,2)-C(0,0)*C(1,2);
adj[2][2]=C(0,0)*C(1,1)-C(1,0)*C(0,1);
complex det=C(0,0)*adj[0][0]+C(0,1)*adj[0][1]+C(0,2)*adj[0][2];
for (int i=0;i<3;i++)
{
for (int j=0; j<3;j++)
{
D[i][j]=adj[i][j]/det;
}
}
matrica H=matrica(D);
return D;
}
/* friend std::ostream & operator << (std::ostream &os, const complex &c)
{ return os << c.re << "+ j" << c.im;)
friend std::istream & operator >> (std::istream &is, const complex &c)
{return is >> c.re >> c.im; }*/
};
#endif //__MATRICA_H
Klasa Transformator:
#include "complex.hpp"
#include "matrica.hpp"
#include <math.h>
class transformator: public branch
{
static int vr, brcv1, brcv2, ind, pret1, pret2, sled;
public:
matrica Y11, Y12, Y21, Y22;
static matrica Iz, Itz, Utz, Ipret1z, Ipret2z, Usledz, Jc;
static matrica I1, I2, U1, U2;
public:
transformator (matrica Yt11, matrica Yt12, matrica Yt21, matrica Yt22): Y11(Yt11), Y12(Yt12), Y21(Yt21), Y22(Yt22){}
matrica getIpret1zt(const branch &grpret1)
{
if (pret1!=0)
{
Ipret1z=grpret1.Itz; // Itzt nije clan klase branch???
}
else
{
Ipret1z=0;
}
return Ipret1z;
}
matrica getIpret2zt(const branch &grpret2)
{
if (pret2!=0)
{
Ipret2z=grpret2.Itz;
}
else
{
Ipret2z=0;
}
return Ipret2z;
}
matrica getUsledzt(const branch &grsled)
{
if (sled!=0)
{
Usledz=grsled.Utz;
}
else
{
Usledz=0;
}
return Usledz;
}
matrica getI2(branch &grpret1, branch &grpret2)const
{
matrica I2pot, S, I2pret1, I2pret2;
for (int i=0; i<3; i++)
{
I2(i,0)=S(i,0)/conjug(U2(i,0));
if (pret1!=0)
{
I2pret1(i,0)=grpret1.I1(i,0);
}
else
{
I2pret1(i,0)=(0,0);
}
if (pret2!=0)
{
I2pret2(i,0)=grpret2.I1(i,0);
}
else
{
I2pret2(i,0)=(0,0);
}
I2(i,0)=I2pot(i,0)+I2pret1(i,0)+I2pret2(i,0)+Jc(i,0);
}
}
matrica getI1()const
{
if (iteracija=1) // ??????????????? uvesti pojam iteracije
{
for (int i=0; i<3; i++)
{
I1(i,0)=(I2(i,0))*(cos (5*M_PI/6), sin(5*M_PI/6));
}
}
else
{
matrica A=Y11*U1;
matrica B=Y12*U2;
I1=A+B;
}
}
matrica getU1(branch &grsled)const
{
U1=grsled.U2;
}
matrica getU2()const
{
matrica E, F;
E=-(inv(Y22))*Y21;
F=-(inv(Y22));
U2=E*U1+F*I2;
return U2;
}
};
#endif //__TRAFO_H
U klasi Transformator, u funkciji getI1, već neće da izračuna matrice A i B. U čemu je problem i kako ga otkloniti?