// NullstellenIteration.java                    MM 2010
import Tools.IO.*;                          // Eingaben

/**
 * Programm zur Nullstellenberechnung von Funktionen.
 */
public class NullstellenIterator
{
/* ------------------------------------------------- */
                                            // Attribut
/**
 * Speichert Differenzierbarkeit.
 */
  private boolean differenzierbar = false;

/* ------------------------------------------------- */
                                              // Dialog
/**
 * Nullstellenberechner:
 * Funktionseingabe, Nullstellenberechnung.
 */
  public void dialog()
  {
// Ueberschrift
    System.out.println();
    System.out.println( "Nullstellenberechner");

// Dialog
    char weiter = 'j';
    do
    {
// Neue Funktion
      Funktion fkt = funktionsAuswahl();
      if( fkt == null) break;
      fkt.konsolenEingabe();

      System.out.println( "\nNullstelle von: " +  fkt);

      do
      {
// Nullstellenberechnung
        System.out.println();
        berechneNullstelle( fkt);

        System.out.println();

// Weiter
        weiter = IOTools.readChar( "Neue Nullstelle (j/n)? ");
      } while( weiter == 'j');

      weiter = IOTools.readChar( "Neue Funktion (j/n)? ");
    } while( weiter == 'j');

// Abschluss
    System.out.println();
    System.out.println( "Programm beendet");
  }

/* ------------------------------------------------- */
                                    // Funktionseingabe
/**
 * Funktionsauswahl.
 * @return Funktion
 */
  public Funktion funktionsAuswahl()
  {
// Menue aller Funktionen
    System.out.println( "Funktionsauswahl");
    System.out.println
    ( "  Gerade                      ... 1");
    System.out.println
    ( "  Polynom                     ... 2");
    System.out.println
    ( "  gebrochenrationale Funktion ... 3");

    int eingabe = IOTools.readInteger(": ");

// Festlegen der Funktion
    Funktion fkt = null;
    switch( eingabe)
    {
      case 1: fkt =  new Gerade();
              differenzierbar = true;
              break;
      case 2: fkt =  new Polynom( );
              differenzierbar = true;
              break;
      case 3: fkt = new RationaleFunktion();
              differenzierbar = false;
              break;
      default: System.out.println();
        System.out.println( "Fehlerhafte Eingabe!");
    }
    return fkt;
  }

/* ------------------------------------------------- */
                                           // Iteration
/**
 * Verfahrensauswahl.
 * @param fkt differenzierbare Funktion
 */
  public void berechneNullstelle( Funktion fkt)
  {
// Berechnen der Nullstelle durch Newton
    if( differenzierbar)
    {
      DifferenzierbareFunktion dfkt
      = (DifferenzierbareFunktion)fkt;

      System.out.println
      ( " Newton:       " + newton( dfkt));

      System.out.println();
    }

// Berechnen des Integrals durch Simpsonregel
      System.out.println
      ( " Regula falsi: " + regulaFalsi( fkt));
  }

/**
 * Berechnet Nullstelle nach Newton.
 * @param fkt DifferenzierbareFunktion
 * @return Nullstellennaeherung
  */
  private double newton( DifferenzierbareFunktion fkt)
  {
    System.out.println( "Newton:");
    System.out.println( "Eingabe der Iterationswerte");

    double x0 =  IOTools.readDouble
                 ( " Startwert   x0 = ");
    double eps = IOTools.readDouble
                 ( " Genauigkeit eps = ");
    int max;
    do
    {
      max = IOTools.readInteger
            ( " maximale Durchlaeufe > 0, max = ");
    } while( max < 1);

    Iteration it = new Iteration();
    return it.newton( fkt, x0, eps, max);
  }

/**
 * Berechnet Nullstelle nach Regula Falsi.
 * @param fkt Funktion
 * @return Nullstellennaeherung
 */
  private double regulaFalsi( Funktion fkt)
  {
    System.out.println( "Regula falsi:");
    System.out.println( "Eingabe der Iterationswerte");

    double x0 = 0, x1 = 0;
    do
    {
      x0 = IOTools.readDouble
           ( " 1. Naeherungswert, f(x0)>0,  x0 = ");
      x1 = IOTools.readDouble
           ( " 2. Naeherungswert, f(x1)<0,  x1 = ");
     } while( fkt.wert( x0) <= 0 || fkt.wert( x1) >= 0);

    double eps = IOTools.readDouble
           ( " Genauigkeit,                eps = ");
    int max;
    do
    {
      max = IOTools.readInteger
           ( " maximale Durchlaeufe > 0,   max = ");
    } while( max < 1);

    Iteration it = new Iteration();
    return  it.regulaFalsi( fkt, x0, x1, eps, max);
  }

/* ------------------------------------------------- */
                                            // Programm
/**
 * Hauptprogramm, startet Nullstellenberechnung.
 */
  public static void main( String[] args)
  {
// Berechner erzeugen
    NullstellenIterator berechner
    = new NullstellenIterator();

// Berechner starten
    berechner.dialog();
  }
}

/* ------------------------------------------------- */
                                           // Testwerte
/*
Nullstellenberechner
Nullstelle von:
24.0 + -2.0 x^1 + -5.0 x^2 + 1.0 x^3

Mathematische Loesung: 4, 3, -2

Newton:
Eingabe der Iterationswerte
  Startwert   x0 = -3
  Genauigkeit eps = 0.0001
  maximale Durchlaeufe > 0, max = 10
0: -3.0
1: -2.2363636363636363
2: -2.01812267760654
3: -2.0001192331463127

Gefundene Nullstelle: -2.0000000052123896         // -2

Eingabe der Iterationswerte
  Startwert   x0 = 0
  Genauigkeit eps = 0.0001
  maximale Durchlaeufe > 0, max = 10
0: 0.0
1: 12.0
2: 8.748387096774193
3: 6.654571080541162
4: 5.348891161080276
5: 4.581524151017727
6: 4.182140953086981
7: 4.028245849809502
8: 4.000879964323257

Gefundene Nullstelle: 4.000000901768636            // 4

Eingabe der Iterationswerte
  Startwert   x0 = 1
  Genauigkeit eps = 0.0001
  maximale Durchlaeufe > 0, max = 10
0: 1.0

Gefundene Nullstelle: 3.0                          // 3
*/