# Näherungswerte berechnen



## stefan.h (22. Nov 2016)

Hallo zusammen,
Ich muss als Hausübung ein Programm schreiben, das Näherungswerte berechnet.
Mein Problem ist, dass das ganze nur bei dem ersten x richtig rechnet!
Seht selbst!
Jemand ne Lösung für mich?
p.s.: so wie bei x= 0.1, sollte es überall aussehen!


```
public class Näherung{
  
   public static void main(String [] args){
    
     char sign = 0;
     double x = 0, diff = 0;         // Variablen deklariern und initialisieren
    
     IO.print("\nNaeherung!");
     IO.print("\n==========\n");
     IO.print("\nBitte geben Sie fuer x einen Wert zwischen 0 und 1 ein: ");
                             // Ausgabe des Kopftextes
     x = read_double_number();             // Einlesen der Eingabe ueber eine Methode
     while (x >= 1 || x <= 0) {                 // Da die Naeherung nur für x < 1 gilt abfragen ob dies zutrifft
       IO.print("\nBitte geben Sie fuer x einen Wert zwischen 0 und 1 ein: ");
       x = read_double_number();
      
     }
     double z= x;
     while(z<=1){  
     IO.print("\nx=");
     System.out.format("%1.1f", z);
     IO.print("\n\n");      
     IO.print("epsilon ----exact---- approximation -- difference --");
     double e=0.1;               // Ueberschrift der Ausgabe ausgeben
     while (e > 0.0000000001) {             // schleife für die 5fache Ausgabe
       double ex= exact(z) + 1;
       diff = difference(x, approximation(z, e));// ermittlung der differenz ueber Methoden
      
       if (diff >= 0) {               // wenn die Differenz > 0 muss sie poetiv sein
         sign = '+';                 // Vorzeichen fuer die Ausgabe speichern
       } else if (diff < 0) {             // wenn die Differenz < 0 muss sie negativ sein
         diff = diff * (-1);             // den Betrag der Differenz bilden
         sign = '-';                 // Vorzeichen fuer die Ausgabe speichern
       }
                             // Ausgabe der Ergebnisse
      
       System.out.printf("\n%1.10f  %1.10f  %1.10f  %1c%1.10f",e, ex, approximation(z, e)+1, sign, diff);
       e= e/100;   // e wird immer kleiner (durch 10) und die Naeherung dadurch immer genauer  
     }
      
    
     IO.print("\n");
     z= z+x;
     e= 0.1;
     }
    
   }//end main
  
public static double exact(double z){
   double exact= 0;
  
   exact= Math.sqrt(1/Math.pow((z+1), 5));
  
   return exact;
  
}
public static double difference(double z, double approx) {
    
     double diff = 0;
     diff =  (exact(z)+1)- (approx+1);   // Berechnung der Differenz
     return diff;                   // Rueckgabe der Differenz
   }   // Ende difference
  
   public static double approximation(double z, double e){  
    
     int i = 5, j = 2, k = 1000, sign = 1;
     double term = 1, upper = z * i, lower = j, approx = 0, diff = 1;   // Variablen deklariern und initialisieren
    
     while (diff > e){                 // Solange die gewuenschte Genauigkeit nicht erreicht ist, wiederhole
      
       approx = approx + (sign * term);       // Naeherung bilden und den term mit abwechselndem Vorzeichen versehen
       term  = upper/lower;             // Term berrechnen
       i = i + 2;                   // Hilfsvariablen erhoehen
       j = j + 2;                   // Hilfsvariablen erhoehen
       upper = upper * z * i / k;           // den Wert von upper anpassen und verhindern das der Type double gesprengt wird -> bei x = 0.9 gehts sonst gegen infinity
       lower = lower * j / k;             // den Wert von lower anpassen und verhindern das der Type double gesprengt wird -Y das verhaeltnis bleibt dabei gleich!
       sign = sign * (-1);               // das Vorzeichen des Terms wechseln
       diff = difference(z, approx);         // Differenz bilden
       if (diff < 0) {                 // Vergleichen ob die Differenz negativ ist  
         diff = diff * (-1);             // Wenn ja, Betrag bilden
       }
     }  
     return approx;                   // Rueckgabe der Naeherung
   }
  
public static double read_double_number () {
    
     char input = IO.read();
     int divider = 1;
     double number = 0;
     boolean comma = false, negativ = false, error = false;   // Variablen deklariern und initialisieren
    
     if (input == '-') {
       negativ = true;
     } else if (input == '+') {
       negativ = false;
     }                         //Vorzeichen beruecksichtigen
     while (input != '\n') {               // solange etwas im Puffer ist, wiederholen
        
       if (input == '.') {
         comma = true;               // wenn ein Komma/Punkt eingelesen wird - merken
       } else if ('0' <= input && input <= '9') {   // wenn es sich um eine Zahl handelt
         number = (number*10) + (input - '0');   // diese zur Nummer hinzufuegen            
         if (comma == true) {           // wenn eine Zahl nach dem komma kommt
           divider = divider * 10;         // erhoehe den Teiler um das 10fache pro Zahl
         }
       } else if (input != ' ' || input != '+' || input != '-') {  
         error = false;
       } else {
         error = true;               // ungueltige Eingaben beruecksichtigen
       }
       input = IO.read();               // naechstes char einlesen
     }  
     if (negativ) {
       number = number * (-1);            // Zahl negativ machen
     }
     if (error) {                   // bei fehlerhafter Eingabe Zahl gleich null setzen
       number = 0;
     }
     return (number/divider);             // Zahl zurueck geben
   }
}//end class
```


----------



## Flown (22. Nov 2016)

Bitte Code-Tags verwenden: [code=java]//JAVA CODE HERE[/code]


----------



## stefan.h (22. Nov 2016)

Hab das Problem gefunden!

```
//diff = difference(x, approximation(z, e))
```
falsch

```
//diff = difference(z, approximation(z, e))
```
richtig


----------

