package zlomky;

/*******************************************************************************
 * Třída Zlomek_4 definuje zlomky a potřebné operace, aby se zlomky bylo
 * možno počítat obdobně jako s čísly. Definuje proto operace pro sčítání,
 * odčítání, násobení a dělení dvou zlomků a zlomku a čísla, 
 * jakož i operace pro převod celého čísla na zlomek a zlomku na číslo.
 *
 * @author     Rudolf Pecinovský
 * @version    0.00.000,  0.0.2003
 */
public class Zlomek_4
{
//== KONSTANTNÍ ATRIBUTY TŘÍDY =================================================
//== PROMĚNNÉ ATRIBUTY TŘÍDY ===================================================
//== KONSTANTNÍ ATRIBUTY INSTANCÍ ==============================================

    private final int čitatel;
    private final int jmenovatel;
    

//== PROMĚNNÉ ATRIBUTY INSTANCÍ ================================================
//== PŘÍSTUPOVÉ METODY VLASTNOSTÍ TŘÍDY ========================================
//== OSTATNÍ METODY TŘÍDY ======================================================

//##############################################################################
//== KONSTRUKTORY A TOVÁRNÍ METODY =============================================

    /***************************************************************************
     * Vytvoří novou instanci třídy Zlomek s hodnotou danou čitatelem a
     * jmenovatelem dodanými jako parametry. Hodnota čitatele a jmenovatele 
     * uložená v atributech však bude již zkrácená a jmenovatel bude kladný.
     * 
     * @param c  Zadávaný čitatel
     * @param j  Zadávaný jmenovatel
     */
    public Zlomek_4(int c, int j)
    {
        int dělitel = Funkce.nsd( c, j );
        if( j < 0 )
        {
            c = -c;
            j = -j;
        }
        čitatel    = c / dělitel;
        jmenovatel = j / dělitel;
    }
    
    
    /***************************************************************************
     * Kopírovací konstruktor -- vytvoří novou instanci 
     * se stejnými hodnotami atributů, jaké má zlomek zadaný jako parametr.
     *
     * @param z  Kopírovaný zlomek
     */
    public Zlomek_4(Zlomek_4 z)
    {
        čitatel    = z.čitatel;
        jmenovatel = z.jmenovatel;
    }
    
    
    /***************************************************************************
     * Vytvoří zlomek, který bude mít hodnotu čísla zadaného jako parametr.
     *
     * @param číslo  Hodnota vytvářeného zlomku
     */
    public Zlomek_4(int číslo)
    {
        čitatel    = číslo;
        jmenovatel = 1;
    }
    

    
//== PŘÍSTUPOVÉ METODY VLASTNOSTÍ INSTANCÍ =====================================

    /***************************************************************************
     * Vrátí hodnotu čitatele.
     * 
     * @return hodnota čitatele              
     */     
    public int getČitatel()
    {
        return čitatel;
    }


    /***************************************************************************
     * Vrátí hodnotu jmenovatele.
     * 
     * @return hodnota jmenovatele              
     */     
    public int getJmenovatel()
    {
        return jmenovatel;
    }



//== PŘEKRYTÉ METODY IMPLEMENTOVANÝCH ROZHRANÍ =================================
//== PŘEKRYTÉ ABSTRAKTNÍ METODY RODIČOVSKÉ TŘÍDY ===============================
//== PŘEKRYTÉ KONKRÉTNÍ METODY RODIČOVSKÉ TŘÍDY ================================
    
    /***************************************************************************
     * Vrátí řetězec reprezentující zlomek ve tvaru
     * [čitatel/jmenovatel]  -  např. [7/2]
     *
     * @return Textová reprezentace zlomku.
     */
public boolean equals( Object o )
{
    if( o instanceof Zlomek )
    {
        Zlomek_4 z = (Zlomek_4)o;
        return (čitatel    == z.čitatel)   &&  
               (jmenovatel == z.jmenovatel);
    }
    else
        return false;
}
    
    
    /***************************************************************************
     * Vrátí řetězec reprezentující zlomek ve tvaru
     * [čitatel/jmenovatel]  -  např. [7/2]
     *
     * @return Textová reprezentace zlomku.
     */
    public String toString()
    {
        return "[" + čitatel + "/" + jmenovatel + "]";
    }
    
    
    
//== NOVĚ ZAVEDENÉ METODY INSTANCÍ =============================================
    
    /***************************************************************************
     * Vrátí hodnotu zlomku oříznutou na celé číslo.
     *
     * @return  Hodnota zlomku oříznutá na celé číslo.
     */
    public int intValue()
    {
        return čitatel / jmenovatel;
    }
    
    
    /***************************************************************************
     * Vrátí hodnotu zlomku převedenou na reálné číslo typu double.
     *
     * @return  Hodnota zlomku převedená na reálné číslo typu double.
     */
    public double doubleValue()
    {
        return (double)čitatel / jmenovatel;
    }

        
    /***************************************************************************
     * Připočte ke zlomku zlomek zadaný jako parametr 
     * a vrátí zlomek, který je jejich součtem. 
     *
     * @param  z  Přičítaný zlomek.
     *
     * @return Zlomek_4, ktrerý je součtem obou zlomků.
     */
    public Zlomek_4 plus(Zlomek_4 z)
    {
        //int násobek = Funkce.nsn( this.jmenovatel, z.jmenovatel );
        return new Zlomek_4( čitatel*z.jmenovatel + z.čitatel*jmenovatel, 
                           jmenovatel*z.jmenovatel );
    }
    
    
    /***************************************************************************
     * Připočte ke zlomku celé číslo zadané jako parametr 
     * a vrátí zlomek, který je jejich součtem. 
     *
     * @param  číslo   Přičítané číslo.
     *
     * @return Zlomek_4, ktrerý je součtem obou hodnot.
     */
    public Zlomek_4 plus(int číslo)
    {
        return new Zlomek_4( čitatel + číslo*jmenovatel, jmenovatel );
    }
    
    
    /***************************************************************************
     * Odečte od zlomku zlomek zadaný jako parametr 
     * a vrátí zlomek, který je jejich rozdílem. 
     *
     * @param  z  Odečítaný zlomek.
     *
     * @return Zlomek_4, ktrerý je rozdílem obou zlomků.
     */
    public Zlomek_4 mínus(Zlomek_4 z)
    {
        //int násobek = Funkce.nsn( this.jmenovatel, z.jmenovatel );
        return new Zlomek_4( čitatel*z.jmenovatel - z.čitatel*jmenovatel, 
                           jmenovatel*z.jmenovatel );
    }
    
    
    /***************************************************************************
     * Odečte od zlomku celé číslo zadané jako parametr 
     * a vrátí zlomek, který je jejich rozdílem. 
     *
     * @param  číslo   Odečítané číslo.
     *
     * @return Zlomek_4, ktrerý je rozdílem obou hodnot.
     */
    public Zlomek_4 mínus(int číslo)
    {
        return new Zlomek_4( čitatel - číslo*jmenovatel, jmenovatel );
    }
    
    
    /***************************************************************************
     * Odečte zlomek od celého čísla zadaného jako parametr 
     * a vrátí zlomek, který je jejich rozdílem. 
     *
     * @param  číslo   Číslo, od kterého se zlomek odečte.
     *
     * @return Zlomek_4, ktrerý je rozdílem obou hodnot.
     */
    public Zlomek_4 odečtiOd(int číslo)
    {
        return new Zlomek_4( číslo*jmenovatel - čitatel, jmenovatel );
    }
    
    
    /***************************************************************************
     * Vynásobí zlomek zlomkem zadaným jako parametr 
     * a vrátí zlomek, který je jejich součinem. 
     *
     * @param  z  Zlomek_4, kterým se násobí.
     *
     * @return Zlomek_4, ktrerý je součinem obou zlomků.
     */
    public Zlomek_4 krát(Zlomek_4 z)
    {
        return new Zlomek_4( čitatel * z.čitatel,  jmenovatel * z.jmenovatel );
    }
    
    
    /***************************************************************************
     * Vynásobí zlomek celým číslem zadaným jako parametr 
     * a vrátí zlomek, který je jejich součinem. 
     *
     * @param  číslo  Číslo, kterým se násobí.
     *
     * @return Zlomek_4, ktrerý je součinem obou hodnot.
     */
    public Zlomek_4 krát(int číslo)
    {
        return new Zlomek_4( čitatel * číslo,  jmenovatel );
    }
    
    
    /***************************************************************************
     * Vydělí zlomek zlomkem zadaným jako parametr 
     * a vrátí zlomek, který je jejich podílem. 
     *
     * @param  z  Zlomek_4, kterým se dělí.
     *
     * @return Zlomek_4, ktrerý je podílem obou zlomků.
     */
    public Zlomek_4 děleno(Zlomek_4 z)
    {
        return new Zlomek_4( čitatel * z.jmenovatel,  jmenovatel * z.čitatel );
    }
    
    
    
    /***************************************************************************
     * Vydělí zlomek celým číslem zadaným jako parametr 
     * a vrátí zlomek, který je jejich podílem. 
     *
     * @param  z  Číslo, kterým se dělí.
     *
     * @return Zlomek_4, ktrerý je podílem obou hodnot.
     */
    public Zlomek_4 děleno(int číslo)
    {
        return new Zlomek_4( čitatel,  jmenovatel * číslo );
    }
    
    
    /***************************************************************************
     * Vydělí zlomkem celé číslo zadané jako parametr 
     * a vrátí zlomek, který je jejich podílem. 
     *
     * @param  z  Číslo, které se dělí.
     *
     * @return Zlomek_4, ktrerý je podílem obou hodnot.
     */
    public Zlomek_4 dělČíslo(int číslo)
    {
        return new Zlomek_4( jmenovatel * číslo,  čitatel );
    }
    

    
//== SOUKROMÉ A POMOCNÉ METODY TŘÍDY ===========================================
//== SOUKROMÉ A POMOCNÉ METODY INSTANCÍ ========================================
//== VNOŘENÉ A VNITŘNÍ TŘÍDY ===================================================
//== TESTY A METODA MAIN =======================================================
}

