/**
*  Numeri complessi
*
* @author Adriano Luchetta
* @version 28-Ott-2004
*
*/

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 cap. 2 Argomenti avanzati 2.3.
   }                // Posso fare a meno di usare l'enunciato this() e scrivere
                    // 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 z2 addendo (il primo addendo e' il parametro implicito this)
   @return la somma z1 + z2
   */
   public Complex add(Complex z2)
   {
      return new Complex(re + z2.re, im + z2.im);
   }

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

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

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

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

   /**
   Calcola il coniugato di un numero complesso
   @return z^
   */
   public Complex conj()
   {
      return new Complex(re, -im);
   }
   
   /**
   restituisce una stringa che rappresenta il numero complesso in formato
   matematico: (x+iy). Esempio: "1+i9" o "2-i7)
   */
   public String toString()
   {
      char sign = '+';
      if (im < 0)
         sign = '-';
      return re + " " + sign  + " i" + Math.abs(im);
   }

   public boolean approxEquals(Complex z2)
   {
      return approx(re,z2.re) && approx(im, z2.im);
   }

   private boolean approx(double x, double y)
   {
      final double EPSILON = 1E-14; // tolleranza

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