Facebook
From Blush Kangaroo, 3 Years ago, written in Plain Text.
Embed
Download Paste or View Raw
Hits: 163
  1. class Zespolona
  2. {private:
  3.     double re , im;
  4.  public:
  5.     Zespolona(double RE = 0, double IM = 0)
  6.     {
  7.         re = RE;
  8.         im = IM;
  9.     }
  10.          
  11.     void print()
  12.     {
  13.         if(im>=0)
  14.             cout<<re<<"+"<<im<<"*i"<<endl;
  15.         else
  16.             cout<<re<<im<<"*i"<<endl;
  17.     }
  18.  //OPERACJE:
  19.     bool operator == (const Zespolona &z)
  20.     {
  21.         if ((re==z.re)&&(im==z.im))return true;
  22.                 else return false;
  23.     }
  24.     Zespolona operator= (const Zespolona &z )
  25.         {
  26.         re = z.re; // Lub setRe( z.getRe() ); (jakby były zrobione akcesory)
  27.         im = z.im; // Lub setIm( z.getIm() );
  28.         }
  29.         Zespolona operator* (int x)
  30.         {
  31.         return Zespolona(re*x,im*x);
  32.     }
  33.         Zespolona operator* (const Zespolona &z)
  34.     {
  35.         return Zespolona(re*z.re-im*z.im,re*z.im+im*z.re);
  36.     }
  37.     Zespolona operator+ (const Zespolona &z)
  38.     {
  39.         return Zespolona(re+z.re, im+z.im);
  40.     }
  41.     Zespolona operator- (const Zespolona &z)
  42.     {
  43.         return Zespolona(re-z.re , im-z.im);
  44.     }
  45.     Zespolona operator/ (const Zespolona &z)
  46.     {
  47.         Zespolona wyn;
  48.         double x = z.re * z.re + z.im * z.im;
  49.         if (x>0)
  50.         {
  51.              wyn.re = (re * z.re + im * z.im)/x;
  52.              wyn.im = (z.re * im - re * z.im)/x;
  53.              return wyn;
  54.         }
  55.         else{cout<<"Nie dziel przez 0!";}
  56.     }
  57.     Zespolona operator+ (const int liczbar)
  58.     {
  59.         return Zespolona(re+liczbar,im);
  60.     }
  61.     friend istream& operator>>(istream& is, Zespolona &z)
  62.         {
  63.             is>>z.re>>z.im;
  64.             return is;
  65.         }
  66.     friend ostream& operator<<(ostream& os, Zespolona &z)
  67.     {
  68.         if      (z.im == 0) {os<<z.re;}
  69.         else if (z.re == 0) {os<<z.im<<"*i";}
  70.         else if (z.im < 0) {os<<z.re<<z.im<<"*i";}
  71.         else    {os<<z.re<<"+"<<z.im<<"*i";}
  72.         return os;
  73.     }
  74.    
  75.     int dlugosc()
  76.         {
  77.         ostringstream os;
  78.         os << *this;
  79.         return os.str().size();
  80.         }
  81.        
  82. };
  83.  
  84.  
  85. class macierz :Zespolona
  86. {private:
  87.     int w;
  88.     int k;
  89.  public:  
  90.     Zespolona **tab;
  91.     macierz(); // konstruktor domyślny
  92.     macierz(const macierz& m) // konstruktor kopiujący
  93.         {
  94.         k = m.k+1;
  95.     w = m.w+1;
  96.     tab = new Zespolona *[w];
  97.     for (int i = 0; i < w; i ++ )
  98.         {
  99.         tab[i] = new Zespolona[k];
  100.                 }
  101.     for (int i = 0; i < w; i ++ )
  102.                 {
  103.         for (int j = 0; j < k; j ++ )
  104.                         {
  105.             tab[i][j] = m.tab[i][j];
  106.                         }
  107.                 }
  108.         }
  109.     macierz(int wiersze, int kolumny) // konstruktor dwuparametrowy
  110.     {
  111.         w = wiersze+1;
  112.         k = kolumny+1;
  113.         tab = new Zespolona* [w];
  114.         for(int i=0 ; i<w ; i++)
  115.         {
  116.             tab[i] = new Zespolona[k];
  117.         }
  118.  
  119.         for(int i=0 ; i<w ; i++)
  120.         {
  121.             for(int j=0 ; j<k ; j++)
  122.             {
  123.                 tab[i][j] = 0;
  124.             }
  125.         }
  126.     }
  127.  
  128.     ~macierz()
  129.     {  
  130.         //cout<<endl<<"Zwalnianie pamieci."<<endl;
  131.          for( int i = 0; i < w; i++ )                
  132.               {delete[]tab[i];}        
  133.               delete[] tab;
  134.     }
  135.  
  136.     void jednostkowa()
  137.     {
  138.         if (w != k) cout<<"Macierz jednostkowa istnieje tylko dla macierzy kwadratowej !"<<endl;
  139.         else
  140.         {
  141.              for(int i=0; i<w ; i++)
  142.             {
  143.                 for(int j=0 ; j<k ; j++)
  144.                 {
  145.                    if(i==j) tab[i][j] = 1;
  146.  
  147.                 }
  148.             }
  149.         }
  150.  
  151.     }
  152.  
  153.     void zamien(int wiersz,int kolumna, Zespolona z)
  154.     {   int exist_kolumna = 0;
  155.         int exist_wiersz = 0;
  156.         for(int i=0 ; i<w ; i++)
  157.         {
  158.             if(wiersz == i) exist_wiersz = 1;
  159.         }
  160.         for(int i=0 ; i<k ; i++)
  161.         {
  162.             if(kolumna == i) exist_kolumna =1;
  163.         }
  164.         if(exist_kolumna==1 && exist_wiersz==1)
  165.         {
  166.             tab[wiersz][kolumna] = z;
  167.         }
  168.         else cout<<endl<<"W tej macierzy nie ma takiej komorki: ["<<wiersz<<"]["<<kolumna<<"] !"<<endl;
  169.  
  170.     }
  171.  
  172.     macierz operator+ (const macierz &m)
  173.     {   macierz suma(w-1,k-1);
  174.  
  175.         if(w!=m.w || k!=m.k) cout<<"Mozna dodawac tylko macierze o takiej samej liczbie wierszy i kolumn."<<endl;
  176.         else
  177.         {
  178.             for(int i=0 ; i<w ; i++)
  179.             {
  180.                 for(int j=0 ; j<k ; j++)
  181.                 {
  182.                    suma.tab[i][j] = tab[i][j] + m.tab[i][j];
  183.                 }
  184.             }
  185.         }
  186.         return suma;
  187.     }
  188. /*
  189.     macierz operator* (int x)
  190.     {  
  191.         macierz iloczyn(w-1,k-1);
  192.  
  193.         for(int i=0 ; i<w ; i++)
  194.         {
  195.             for(int j=0 ; j<k ; j++)
  196.             {
  197.                 iloczyn.tab[i][j] = x * tab[i][j];
  198.             }
  199.         }
  200.         return iloczyn;
  201.     }
  202. */     
  203. /*
  204.         macierz operator* (int x)
  205.         {      
  206.                 macierz iloczyn(w-1,k-1);
  207.                
  208.                 for(int i=0 ; i<w ; i++)
  209.         {
  210.             for(int j=0 ; j<k ; j++)
  211.             {
  212.                 iloczyn.tab[i][j] = tab[i][j] * x;
  213.                 }
  214.         }
  215.                 return iloczyn;
  216.         }
  217. */     
  218.         friend macierz operator* (int x,const macierz& m)
  219.         {      
  220.                 macierz iloczyn(m.w,m.k);
  221.                 Zespolona**tab = m.tab;
  222.                 for(int i=0 ; i<m.w ; i++)
  223.         {
  224.             for(int j=0 ; j<m.k ; j++)
  225.             {
  226.                 iloczyn.zamien(i+1,j+1,tab[i][j]*x);
  227.                 }
  228.         }
  229.                 return iloczyn;
  230.         }
  231.        
  232.          void operator= (const macierz &m)
  233.     {
  234.         tab=m.tab;
  235.     }
  236.    
  237. /*     
  238.     macierz operator= (const macierz &m)
  239.     {
  240.         macierz porownanie(w,k);
  241.  
  242.         for(int i=0 ; i<w ; i++)
  243.         {
  244.             for(int j=0 ; j<k ; j++)
  245.             {
  246.                 porownanie.tab[i][j] = m.tab[i][j];
  247.             }
  248.         }
  249.         return porownanie;
  250.     }
  251. */      
  252.         friend ostream& operator << (ostream& os,const macierz & m)
  253.         {
  254.                 os << "dim: "<<m.w<<","<<m.k;
  255.                 os << endl;
  256.                 os << (char)218;
  257.                 int *maxL =new int[m.k];
  258.                 for (int j=0;j<m.k;j++)
  259.                 {
  260.                 maxL[j]=0;
  261.                 for (int i=0;i<m.w;i++)
  262.                         {
  263.                         if (maxL[j]<m.tab[i][j].dlugosc())maxL[j]=m.tab[i][j].dlugosc();
  264.                         }
  265.                 }
  266.                 //drukuj:
  267.                 for (int j=0;j<m.k;j++)
  268.                         {
  269.                         for (int i=0;i<maxL[j];i++) os << " ";
  270.                         if (j!=m.k-1) os <<" ";
  271.                         }
  272.                 os << (char)191<<endl;
  273.                 for (int i=0;i<m.w;i++)
  274.                         {
  275.                         os << (char)179;
  276.                         for (int j=0;j<m.k;j++)
  277.                                 {
  278.                                 for (int z=0; z<maxL[j]- m.tab[i][j].dlugosc();z++)os << " ";
  279.                                 os << m.tab[i][j];
  280.                                 if (j<m.k-1) os << " ";
  281.                                 }
  282.                         os << (char)179<<endl;
  283.                         }
  284.                 os << (char)192;
  285.                 for (int j=0;j<m.k;j++)
  286.                 {
  287.                 for (int i=0;i<maxL[j];i++) os << " ";
  288.                 if (j!=m.k-1) os <<" ";
  289.                 }os << (char)217<<endl;
  290.         }
  291.  
  292. };
  293.  
  294. int main(){
  295.  
  296. macierz A(2,2) ,B(2,2),C=A;
  297. A.jednostkowa();
  298. cout << A << endl << C; //pierwszy test czy A!=C
  299. Zespolona u(4,3);
  300. B.zamien(1,1,u);
  301. C=A;
  302. A=6*A;
  303. cout << A << endl << C; //drugi test czy A!=C
  304. C=A+B;
  305. cout << C;
  306.  
  307. return 0;
  308. }