Zobrazenie zdroja stránky Java - trieda Complex

{{Navigacne menu - java}}
__TOC__
[[Súbor:komplexné číslo.svg|left|thumb|Vizualizácia komplexného čísla]]
Komplexné čísla majú dôležitú úlohu technických disciplínach ako sú napríklad matematika, fyzika, elektrotechnika a iné. Zavedenie komplexných čísel nám dovoľuje riešiť úlohu, ktoré boli dovtedy neriešiteľné. Ako najjednoduchší prípad taktejto rovnice je <math>x^2+1=0</math>. Z tejto rovnice vychádza aj samotná definícia komplexného čísla. Komplexná jednotka i je definovaná ako:

<math>i=\sqrt{-1}</math>

Komplexé číslo pozostáva z reálnej časti a imaginárnej časti: <math>A=a+bi</math>.

==Trieda Complex==
Pre prácu s komplexnými číslami v jazyku Java si vytvoríme novú triedu - ''Complex''. Táto trieda bude reprezentovať jedno komplexné číslo. Trieda ''Complex'' bude obsahovať 2 vnútorné premenné reprezentujúce reálnu a imaginárnu časť komplexného čísla. Ďalej bude obsahovať metódy pre prácu s komplexnými číslami ako sú napríklad sčítavanie, násobenie, delenie komplexných čísel, ďalej metódy, ktoré zistia absolútnu hodnotu komplexného čísla alebo argument komplexného čísla.

Štruktúra celej triedy ja následovná:
<source lang="java">
public class Complex{
 private double Re,Im;
 
 // konstruktory

 // pristupove metody

 // ostatne metody
}

</source>

===Konštruktory triedy Complex===
Pre triedu Complex si vytvoríme si viacero konštruktorov. Ako prvý bude implicitný konštruktor bez parametrov. Tento konštruktor vytvorí nové komplexné číslo a do reálnej aj imaginárnej časti vloží hodnoty 0. Teda, nové komplexné číslo bude mať hodnotu 0+0i.

<source lang="java">
    public Complex()
    {
        this.Re=0;
        this.Im=0;        
    }
</source>

Ďalší konštruktor bude konverzný konštruktor s 2-mi parametrami. Podľa hodnoty parametrov bude mať hodnotu aj novo vytvárané komplexné číslo.

<source lang="java">
    public Complex(double a, double b)
    {
        this.Re=a;
        this.Im=b;        
    }
</source>

Tretí konštruktor bude konzerzný konštruktor, teda taký ktorý vytvorí nové komplexné číslo z už existujúceho komplexného čísla tak, že skopíruje jeho hodnoty reálnej a imaginárnej časti.

<source lang="java">
    public Complex(Complex X)
    {
        this.Re=X.Re;
        this.Im=X.Im;        
    }
</source>

Všimnime si, že vo všetkých konštruktoroch je rovnaký kód pre vytváranie komplexného čísla.  Ponechajme si teda len jednu kompletnú definíciu a pri ostatných konštruktoroch sa odkazujme na túto definíciu. Najuviverzálnejší konštruktor je v našom prípade konverzný konštruktor, ktorý má dva paramtre. Pri ostatných konštruktoroch budeme teda volať na tento konštruktor pomocou kľúčového slova ''this''. Samozrejme, musíme uviesť parametre v tomto konštruktore.
Ešte raz uvedieme zoznam konštruktorov aj s elimináciou duplicitného kódu v konštruktoroch:

<source lang="java">
    public Complex()
    {
        this(0,0);
    }
    
    public Complex(double a, double b)
    {
        this.Re=a;
        this.Im=b;        
    }
    
    public Complex(Complex X)
    {
        this(X.Re, X.Im);
    }
</source>

===settery===
Pre triedu ''Complex'' definujme jednu metódu, ktorá nastaví nové hodnotu v reálnej aj imaginárnej čsti komplexného čísla:

<source lang="java">
    public void setComplex(double a, double b){
        this.Re=a;
        this.Im=b;        
    }
</source>
===gettery===
Keďže vlastnosti (''Re, Im'') triedy ''Complex'' sú privátne, potrebujeme k nim prístupové metódy zvlášť k reálnej a zvlášť k imaginárnej časti komplexného čísla. Metódy sú veľmi jednoduché a nepotrebujú ani dodatočný výklad.

<source lang="java">
    public double getRe(){
        return this.Re;
    }
    public double getIm(){
        return this.Im;
    }  
</source>

Komplexné číslo môžeme vyjadriť súradnicami - reálna a imaginárna časť, ale aj vzdialenosťou od čísla 0 a uhlom, ktorý zviera s reálnou osou.

[[Súbor:komplexné číslo 2.svg|center|frame|Vyjadrenie komplexného čísla pomocou jeho veľkosti a uhla <math>\phi</math>]]

Označmi si absolútnu hodnotu komplexného čísla 9X=a+bi) ako R. Pre výpočet R použijeme Pytagorovu vetu:

<math>R=\sqrt{a^2+b^2}</math>

Uhol <math>\phi</math> vypočítame pomocou goniometrických funkcií ako:

<math>\phi = arctan{\frac{b}{a}}</math>

V našej triede Complex je riešenie jednoduché, stačí si uvedomiť, že ''a'' je reálna časť a ''b'' je imaginárna časť komplexného čísla.

<source lang="java">
    public double getR(){    
        return Math.sqrt( Math.pow(this.Re, 2)+Math.pow(this.Im, 2));
    }
    
    public double getFi(){
        return Math.atan(this.Im/this.Re);   
    }
</source>

Druhá odmocnina je v Jave statická metóda ''sqrt'' triedy ''Math''. Výraz Math.pow(x,y) je výpočet mocniny <math>x^y</math>. Funckia arctan(x) (arcus tangens) je definovaná ako Math.atan(x).

===Aritmetika komplexných čísel===
'''Sčítanie (odčítanie) komplexných čísel'''
Komplexné čísla sčítavame/odčítavame tak, že sčítame/odčítame zvlášť ich reálne a zvlášť ich imaginárne časti. Majme komplexné čísla X a Y a vypočítajme Z=X+Y:
<source lang="text">
   X=a+ib
   Y=c+id
   Z= X+Y = (a+c) + i(b+d)
</source>

Implemetácia v Jave:
<source lang="java">
    public Complex add(Complex Y){
       Complex Z=new Complex();
       Z.Re=this.Re+Y.Re;
       Z.Im=this.Im+Y.Im;
       return Z;
    }
    
     public Complex add(double y){
       Complex Z=new Complex();
       Z.Re=this.Re+y;     
       Z.Im=this.Im;
       return Z;         
     }
</source>
V druhom prípade uvažujeme o súčte komplexného čísla a reálneho čísla.


'''Násobenie komplexný čísel'''

Pri násobení komplexných čísel násobíme tak, ako keby boli komplexné čísla polynómy. Teda každú časť prvého komplexného čísal s každou časťou druhého komplexného čísla. Opäť si ukážeme príklad, ale teraz budeme požítať Z=X*Y:
<source lang="text">
   X=a+ib
   Y=c+id
   Z= X*Y = (a+ib) + (c+id)
          = a*c +i*a*d + i*b*c + i*i*d*b
          = (a*c-d*b) + i(a*d + b*c)
</source>
Poznámka: vieme, že komplexná jednotka je definované ako <math>i=\sqrt{-1}</math>, preto <math>i^2=-1</math>

Implemetácia v Jave:
<source lang="java">
     public Complex mult(Complex Y){
       Complex Z=new Complex();
       Z.Re=(this.Re*Y.Re - this.Im*Y.Im);
       Z.Im=(this.Im*Y.Re + this.Re*Y.Im);
       return Z;         
     }
     
      public Complex mult(double y){
       Complex Z=new Complex();
       Z.Re=this.Re * y;
       Z.Im=this.Im * y
       return Z;         
     }
</source>
V druhom prípade uvažujeme o súčine komplexného čísla a reálneho čísla.

'''Podiel komplexných čísel'''

Komplexné čísla sa nedajú deliť, avšak vieme si ich upraviť tak, aby v delenec nebol komplexné číslo, ale len reálne číslo. Pred tým si ale definujme metódu, ktorá vypočíta komplexne združené (konjungované) číslo ku komplexnému číslu X. Nasledujúci obrázok ilustruje komplexné číslo X a komplexne združené číslo ku číslu X. Len poznamenáme, že jedinou zmenou je zman znamienka v imaginárnej časti komplexného čísla.


[[Súbor:komplexne združené číslo.svg|center|frame|Komplexne združené číslo]]

Implementácia v Jave:
<source lang="java">
     public void conj(){
         this.Im*=-1;
     }
</source>

Podiel dvoch komplexných čísel X a Y môžeme vyjadriť nasledovne:
<math>X=a+bi</math>

<math>Y=c+di</math>

<math>Z=\frac{X}{Y}=\frac{X}{Y}*\frac{\bar{Y}}{\bar{Y}}=\frac{X*\bar{Y}}{Y*\bar{Y}}=\frac{X*\bar{Y}}{c^2+d^2}</math>

Implementácia v Jave:
<source lang="java">
    public Complex div(Complex Y) {
        Complex Z = new Complex();
        double menovatel = Y.Re * Y.Re + Y.Im * Y.Im;
        Y.conj();
        Z = this.mult(Y);
        Z.mult(1 / menovatel);
        return Z;
    }
</source>


'''Umocňovanie komplexných čísel'''

Komplexné číslo sa dá vyjariť pomocou reálnej a imaginárnej časti

<math>X= a + bi\,</math>,

ale aj s pomocou absolútnej hodnoty a uhla <math>\phi</math>. 

<math>X=R*(\cos{\phi}+i\sin{\phi}) \,</math>

Z tohto zápisu je zrejmé, že 


<math>a=R*\cos{\phi}\,</math>

a

<math>b=R*\sin{\phi}\,</math>

V tomto zápise je veľmi jednoduché vypočítať ľubovoľnú mocninu čísla X. Umocňovanie je totižto definované ako:

<math>X^n=R^n*(\cos{n*\phi}+i\sin{n*\phi}) \,</math>

Implementácia v Jave:
<source lang="java">
    public Complex pow(double n) {
        double r, fi;
        r = Math.pow(this.getR(), n);
        fi = this.getFi() * n;

        Complex Z = new Complex();
        Z.setComplex(r * Math.cos(fi), r * Math.sin(fi));
        return Z;
    }
</source>

Pre úplnosť uveďme ešte metódu preťaženú ''toString''

<source lang="java">
    public String toString(){
        String x=String.valueOf(this.Re);
        if(this.Im<0)
            x+="-i"+this.Im*-1;
        else
            x+="+i"+this.Im;
        return x;
    }
</source>
==Použitie triedy Complex==
Triedu Complex môžeme použiť v ľubovoľnej ďalšej aplikácii. Tu si ukážeme spôsob, použitia v najjednoduchšom prípade - konzolovej aplikácie.
Komentár k použitiu bude uvedený priamo v zdrojovom kóde.
<source lang="java">
public static void main(String[] args){
        // zavola sa implicitny konstruktor
        Complex X=new Complex();
        // zavola sa konverzny konstruktor
        Complex Y=new Complex(2,-3);
        // zavola sa kopirovaci konstruktor
        Complex Z=new Complex(X);

        //pouzitie metody pre nastavenie novej hodnoty
        // komplexneho cisla
        X.setComplex(-4,5);

        // scitanie: Z=X+Y
        Z=X.add(Y);
        System.out.println(Z);

        // nasobenie: Z=X*Y
        Z=X.mult(Y);
        System.out.println(Z);

        // delenie: Z=X/Y
        Z=X.div(Y);
        System.out.println(Z);

        // umocnenie: Z=X^3
        Z=X.pow(3);
        System.out.println(Z);
}
</source>