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

public class CalcolatoreNumerico
{
   /** 
      verifica se un numero intero positivo e' primo

      @param n numero intero da verificare
      @return false se n ha divisori, true se e' primo
      @throws IllegalArgumentException
   */
   public static boolean primo(int n)
   {
      // verifica precondizioni
      if (n < 1)
        throw new IllegalArgumentException(n + " valore non ammesso"); 

      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

      @param p il primo numero
      @param q il secondo numero
      @return il MCD calcolato
      @throws IllegalArgumentException
   */
   public static int mcd(int p, int q)
   {
      // verifica precondizioni
      if (p < 1 || q < 1)
        throw new IllegalArgumentException(p + " " + q + " valori non ammessi");

      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

      @param n numero intero positivo su cui operare la scomposizione
      @return stringa contenente la scomposizione, ad esempio "1 * 2 * 3 * 7" per n = 42
      @throws IllegalArgumentException
   */
   public static String fattori(int n)
   {
      // verifica precondizioni
      if (n < 1)
        throw new IllegalArgumentException();

      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

      @param n indice della successione
      @return il termine n-esimo f(n) della successione
      @throws IllegalArgumentException
   */
   public static int fibonacci(int n)
   {
      // verifica precondizioni
      if (n < 0)
        throw new IllegalArgumentException();

      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
       
       @param n indice della successione
       @return il termine n-esimo t(n) della successione
       @throws IllegalArgumentException
   */
   public static int triangolare(int n)
   {
      // verifica precondizioni
      if (n < 1)
        throw new IllegalArgumentException();

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