#include "studio.h"

/* Numero di passi in cui l'intervallo viene inizialmente diviso 
   per la ricerca di punti interessanti. */
#define NSTEPS 10
/* Valore della precisione con cui vengono determinati i punti. */
#define PRECISIONE 0.000001
/* Numero massimo di caratteri letti da una linea dello standard input. */
#define MAXLENGTH 200

int main(int argc, char* argv[]) {
  /* Definizione di FaiLoStudio, l'implementazione e' in fondo al file. */
  void FaiLoStudio(double, double, int, double);
  double lowerlimit,upperlimit;
  char linea[MAXLENGTH+1]; 
  /* In linea deve finire cio' che viene letto dallo standard input, 
   * quindi le diamo una dimensone ragionevole (non vorrete scrivere
   * piu' di 200 caratteri su una riga?)
   */

  /* Legge i parametri dell'intervallo dalla riga di comando. */
  if ( argc==3 ) {
    /* 
     * Se ci sono due parametri sulla rica di comando, allora vengono
     * usati come estremi dell'intervallo. 
     * La funzione per fare lo studio viene invocata e poi il programma
     * termina.
     */
    sscanf(argv[1],"%lg",&lowerlimit);
    sscanf(argv[2],"%lg",&upperlimit);
    FaiLoStudio(lowerlimit,upperlimit,NSTEPS,PRECISIONE);
    exit (0);
  } else if ( argc==1 ) {
    /* 
     * Se non ci sono parametri sulla riga di comando, 
     * allora il programma entra in un ciclo in cui li chiede 
     * interattivamente, fino a quando l'utente non prece CTRL-D
     */
    while ( 1 ) {
      /* Il ciclo viene ripetuto indefinitamente fino a quando l'utente
         non termina l'input con CTRL-D. */
      printf("\nInserisci il minimo ed il massimo dell'intervallo (CTRL-D per finire):\n");
      /* Come funziona questo if? 
         Usate 'man gets' per vedere cosa fa la funzione */
      if ( fgets(linea,MAXLENGTH,stdin) ) {
        sscanf(linea,"%lg%lg",&lowerlimit,&upperlimit);
        FaiLoStudio(lowerlimit,upperlimit,NSTEPS,PRECISIONE);
      } else {
	exit (0);
      }
    } 
  } else {
    /* altrimenti stampa l'uso della funzione */
    fprintf(stderr,"Usage: studio x_minimo x_massimo\n");
    exit(-2);
  }
}

void FaiLoStudio(double lowerlimit, double upperlimit, 
		 int passi, double precisione) {
  /*
   * FaiLoStudio divide l'intervallo [lowerlimit,upperlimit] in un numero
   * di sottointervalli definito dall'argomento passi.
   * Le valutazioni della funzione agli estremi dei sottointervalli vengono
   * usate per stimare se essi contengono zeri, massimo o minimi, con la
   * precisione definita dall'omonima variabile.
   */
  /* funzione e' definita in una libreria esterna */
  extern double funzione(double);
  int i;
  double stepsize;
  /*
   * Questa dichiarazione di x ed y va bene se passi e' fisso ed uguale a
   * NSTEPS.
   * Se volete rendere il numero di passi variabile bisognera':
   *  - trasformare x ed y in puntatori a double
   *  - usare malloc per allocare memoria sufficiente a contenere gli 
   *    array ed assegnare tale memoria ai puntatori x ed y, ad esempio:
   *    x = malloc( ????? * sizeof( ????? ) );
   *    Cosa dovete mettere al posto dei ????? ?
   */
  double x[NSTEPS+1];
  double y[NSTEPS+1];

  /* Inizializzazione del pacchetto (in interfaccia.h) 
     per lo studio di funzione. */
  DefinisciFunzione(funzione,lowerlimit,upperlimit);
  DefinisciPrecisione(precisione);

  /* Calcolo del valore della funzione negli estremi dei sottointervalli */
  stepsize = (upperlimit-lowerlimit)/passi;
  for (i=0; i<=passi; i++) {
    x[i]=lowerlimit+i*stepsize;
    y[i]=funzione(x[i]);
  }

  /* Seleziona i sottointervalli che sicuramente contengono uno zero. */
  for (i=0; i<passi; i++) {
    if ( y[i]*y[i+1] <= 0. ) CercaZero(x[i],x[i+1]);
  }

  /* Seleziona i sottintervalli che sicuramente contengono un massimo 
     o un minimo. */
  for (i=1; i<passi; i++) {
    if ( y[i]>=y[i-1] && y[i]>=y[i+1]) CercaMassimo(x[i-1],x[i+1]);
    if ( y[i]<=y[i-1] && y[i]<=y[i+1]) CercaMinimo(x[i-1],x[i+1]);
  }

  /* Recupera i valori del massimo e minimo assoluto della funzione. */
  MassimoAssoluto();
  MinimoAssoluto();

  /*
   * Se il numero di passi e' fisso, pari a NSTEPS, allora si puo' uscire 
   * tranquillamente, altrimenti, ricordatevi di restituire la memoria
   * che e' stata precedentemente allocata a x ed y.
   */

}