/**
 * CalcolatoreNumerico
 * contiene metodi statici per elaborazioni sui numeri interi.
 *
 * @author Adriano Luchetta
 *
 * @version 3-Nov-2007
 * @version 21-Ott-2005
 * @version 6-Nov-2004
 * @version 18-Ott-2003
 *
 */

public class CalcolatoreNumerico
{
   /** 
      Verifica se un numero intero positivo e' primo.
      Se il numero non e' positivo, il programma viene interrotto.
      @param n numero intero da verificare
      @return false se n ha divisori, true se e' primo
   */
   public static boolean primo(int n)
   {
      // verifica precondizioni
      if (n < 1)
      {
         System.out.println("primo(): " + n + " valore non ammesso");
         System.exit(1);
      }

      int j = 2;
      while (j * j  <= n)
      {
         if (n % j == 0)
            return false;
         j++;
      }

      return true;
   }
   
   /**
      calcola il Massimo Comun Divisore (MCD) di due numeri interi positivi p e q.
      Se il numero non e' positivo, il programma viene interrotto.
      @param p il primo numero
      @param q il secondo numero
      @return il MCD calcolato
   */
   public static int mcd(int p, int q)
   {
      // verifica precondizioni
      if (p < 1 || q < 1)
      {
         System.out.println("mcd(): " + p + " " + q + " valori non ammessi");
         System.exit(1);
      }

      int max = p;
      int min = q;
      if (p < q)
      {
         max = q;
         min = p;
      }

      int k;
      while ((k = max % min) > 0)
      {
         max = min;
         min = k;
      }

      return min;
   }
   
   /**
      Scompone in fattori primi un numero intero positivo n.
      Esempio: n = 42 = 1 * 2 * 3 * 7.
      Se il numero non e' positivo, il programma viene interrotto.

      @param n numero intero positivo su cui operare la scomposizione
      @return stringa contenente la scomposizione, ad esempio "1 * 2 * 3 * 7" per n = 42
   */
   public static String fattori(int n)
   {
      // verifica precondizioni
      if (n < 1)
      {
         System.out.println("fattori(): " + n + " valore non ammesso");
         System.exit(1);
      }

      String stringFattori = "1";
      int k = n;
      int j = 2;
      while (j * j <= k)
      {
         while (k % j == 0)
         {
            stringFattori = stringFattori + " * " + j; // trovato un divisore
            k = k / j;              // il nuovo numero da fattorizzare e' k / j
         }
         j++;
      }

      if (k > 1)                    // se k e' maggiore di 1 allora e' un divisore
         stringFattori += " * " + String.valueOf(k);
      return stringFattori;
   }
   
   /**
      Restituisce il termine n-esimo della successione di Fibonacci:
      f(0) = 1, f(1) = 1, f(n) = f(n-2) + f(n-1) per n > 1.
      Se il numero non e' positivo, il programma viene interrotto.

      @param n indice della successione
      @return il termine n-esimo f(n) della successione
   */
   public static int fibonacci(int n)
   {
      // verifica precondizioni
      if (n < 0)
      {
         System.out.println("fibonacci(): " + n + " valore non ammesso");
         System.exit(1);
      }

      if (n == 0 || n == 1)
         return 1;

      int f_old = 1;
      int f = 1;

      int j = 2;
      while (j <= n)
      {
         int tmp = f_old;
         f_old = f;
         f += tmp;;
         j++;
      }

      return f;
   }
   
   /**
      Restituisce il termine n-esimo della successione dei numeri triangolari:
      t(n) = n * (n + 1) / 2 = n + (n - 1) +...+ 2 + 1, per n >= 1.
      Se il numero non e' positivo, il programma viene interrotto.

      @param n indice della successione
      @return il termine n-esimo t(n) della successione
   */
   public static int triangolare(int n)
   {
      // verifica precondizioni
      if (n < 1)
      {
         System.out.println("triangolare(): " + n + " valore non ammesso");
         System.exit(1);
      }

      return n * (n + 1) / 2;
   }
}