/**
 *  Numeri complessi
 *
 * @author Adriano Luchetta
 * @version 15-Ott-2005
 *
 */

public class Complex
{
   // parte privata
   private double re; //parte reale
   private double im; //parte immaginaria
   
   // parte pubblica

   /**
      inizializza il numero complesso al valore re + i*im
      @param re parte reale
      @param im parte immaginaria
   */
   public Complex(double re, double im)   // pessimo stile dare lo stesso nome
   {                                      // ai parametri e alle variabili di
                                          // esemplare!!!
      this.re = re;     // con il riferimento this, pero', si puo' risolvere l'ambiguita'
      this.im = im;     // uno stile migliore: usare nomi diversi per i parametri espliciti
                        // ad esempio: double real; double immag;
   }

   /**
      inizializza il numero complesso al valore re + i0
      @param re parte reale
   */
   public Complex(double re)
   {
      this(re, 0);  /* enunciato strano!!! Vedere Horstmann 3^ Ed. cap. 3 Argomenti avanzati 3.1.
                       enunciato strano!!! Vedere Horstmann 2^ Ed. cap. 2 Argomenti avanzati 2.3.
                       In alternativa a questo enunciato posso scrivere semplicemente:
                       this.re = re; this.im = 0;
                    */
   } 

   /**
      inizializza il numero complesso al valore 0 + i0 (zero complesso)
   */
   public Complex()
   {
      this(0);
   }

   /**
      Esegue la somma di due numeri complessi
      @param z addendo (il primo addendo e' il parametro implicito this)
      @return la somma z1 + z
   */
   public Complex add(Complex z)
   {
      return new Complex(re + z.re, im + z.im);
   }

   /**
      Esegue la sottrazione di due numeri complessi
      @param z sottraendo (il minuendo e' il parametro implicito this)
      @return la sottrazione z1 - z
   */
   public Complex sub(Complex z)
   {
      return new Complex(re - z.re, im - z.im);
   }

   /**
      Esegue la moltiplicazione di due numeri complessi
      @param z secondo fattore del prodotto (il primo fattore e' this)
      @return il prodotto z1 * z
   */
   public Complex mult(Complex z)
   {
      return new Complex(re * z.re - im * z.im, re * z.im + im * z.re);
   }

   /**
      Esegue la divisione fra due numeri complessi
      @param z divisore (il dividendo e' this)
      @return il quoziente z1 / z
   */
   public Complex div(Complex z)
   {
      return mult(z.inv());
   }

   /**
      Calcola l'inverso rispetto al prodotto di un numero complesso
      @return 1/z
   */
   public Complex inv()
   {
      return new Complex(re / (mod() * mod()), -im / (mod() * mod()));
   }

   /**
      Calcola il coniugato di un numero complesso
      @return z^
   */
   public Complex conj()
   {
      return new Complex(re, -im);
   }
   
   /**
      Restituisce il modulo di un numero complesso
      @return |z|
   */
   public double mod()
   {
      return Math.sqrt(re * re + im * im);
   }

   /**
      Restituisce la parte reale di un numero complesso
      @return re
   */
   public double re()
   {
      return re;
   }
   
   /**
      Restituisce la parte complessa di un numero complesso
      @return re
   */
   public double im()
   {
      return im;
   }
   
   /**
      restituisce una stringa che rappresenta il numero complesso in formato
      matematico: x +iy. (Esempio: "1 +9j" o "2 -7j")
   */
   public String toString()
   {
      final String UNITA_IMMAGINARIA = "j";

      if (equalsApprox(im , 0))
         return String.valueOf(re);

      if (equalsApprox(re , 0))
         return String.valueOf(im) + UNITA_IMMAGINARIA;
         
      String sign = "";
      if (im > 0)
         sign = "+";
         
      return re + " " + sign + im + UNITA_IMMAGINARIA;
   }


   /**
      Confronta con tolleranza due numeri complessi. Il due numeri sono
      considerati uguali con tolleranza se entrambe le parti reali e immaginarie
      sono uguali con tolleranza.
      @return true se i numeri sono eguali con tolleranza, false altrimenti
   */
   public boolean equalsApprox(Complex z)
   {
      return equalsApprox(re,z.re) && equalsApprox(im, z.im);
   }

   /*
      metodo privato per confrontare con tolleranza due numeri di tipo double
      E' definito privato perche' viene usato solo all'interno della calsse.
      E' definito static perche' elabora solo i parametri formali.
      Notare che per i metodi privati non si fanno commenti nello stile
      'javadic'
   */
   private static boolean equalsApprox(double x, double y)
   {
      final double EPSILON = 1E-14; // tolleranza

      return Math.abs(x-y) <= EPSILON *
         Math.max(Math.abs(x), Math.abs(y));
   }
}