Last active
May 13, 2018 13:05
-
-
Save bellackn/53e95a3138ae5066edd370ca9df5f36f to your computer and use it in GitHub Desktop.
Create a polynom and do some calculations with it.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// Polynom.java | |
/* Anmerkung: In diesem Programm werden keine negativen Koeffizienten erzeugt, | |
* d.h., dass Polynome mit positivem Grad niemals Nullstellen besitzen. | |
* | |
* Außerdem wird die Nullstellenberechnung bei sehr hohem Grad des Polynoms | |
* ungenau, was wohl an Rundungsfehlern liegt. | |
*/ | |
import java.util.*; | |
import java.io.*; | |
public class Polynom { | |
private int[] coeff; | |
private int grad; | |
protected Polynom() { | |
//Identitaetsfunktion erzeugen | |
this.grad = 1; | |
coeff = new int[grad+1]; | |
coeff[0] = 0; | |
coeff[1] = 1; | |
} //Ende Polynom | |
protected Polynom(int grad) { | |
//Konstruktur, der gewuenschte Gradzahl uebergeben bekommt | |
this.grad = grad; | |
Random rnd = new Random(); | |
coeff = new int[grad+1]; | |
int i = 0; | |
for (i = 0; i < grad; i++ ) { | |
coeff[i] = (rnd.nextInt(10))+1; //Die Koeffizienten sind <= 10 | |
} //Negative Koeffizienten sind nicht vorgesehen | |
coeff[i] = (rnd.nextInt(10))+1; | |
} //Ende Polynom | |
protected void fktWert(int x) { | |
//Berechnen des Funktionswertes fuer ein einzusetzendes x | |
int fktWert = 0; | |
int i = 0; | |
int j = coeff.length - 1; | |
while (i != coeff.length - 1) { | |
fktWert += coeff[i] * Math.pow(x, j); | |
i++; | |
j--; | |
} | |
fktWert += coeff[i]; | |
System.out.println(); | |
System.out.println(); | |
System.out.println("Der Funktionswert fuer x = " + x + " lautet: " + fktWert); | |
} //Ende fktWert | |
protected void newton() { | |
//Finden einer Nullstelle mit dem Newton-Verfahren | |
//1. Schritt: 1. Ableitung des Polynoms bilden | |
System.out.println(); | |
System.out.println("Die 1. Ableitung des Polynoms lautet: "); | |
int[] ableitung; | |
ableitung = new int[coeff.length - 1]; | |
int i = 0; | |
int j = coeff.length - 1; | |
while (i < coeff.length - 1) { | |
ableitung[i] = (coeff[i] * j); | |
if (j-1 == 0) { | |
System.out.print(ableitung[i]); | |
break; | |
} | |
else { | |
System.out.print(ableitung[i] + "x^" + (j-1) + " + "); | |
i++; | |
j--; | |
} | |
} | |
System.out.println(); | |
System.out.println(); | |
//2. Schritt: Naeherungsweises Bestimmen einr Nullstelle | |
//-> Verschiedene x-Werte sollen eingesetzt werden, um festzustellen, | |
//wann der Funktionswert zwischen <0 und >0 wechselt | |
int x = -5; //x-Werte von -5 bis 5 zur Wertetabellenerstellung | |
double[] wertetabelle; | |
wertetabelle = new double[2 * Math.abs(x) + 1]; //Wertetabelle mit 20 Plaetzen | |
double[] grenze; //Hier werden die zwei Werte gespeichert, zwischen denen die Nullstelle liegt | |
grenze = new double[2]; | |
grenze[0] = 6; | |
grenze[1] = 6; //"Dummy-Werte", um später Fehler bei der Array-Initialisierung zu vermeiden | |
//Schleifen, die die Wertetabelle fuellen | |
System.out.println("Die Wertetabelle für x = " + x + " bis " + Math.abs(x) + " lautet: "); | |
i = 0; | |
int k = 0; //Zweite Zaehlvariable | |
j = coeff.length - 1; | |
int sum = 0; //Zur Aufsummierung der einzelnen Funktionswerte | |
while (i != wertetabelle.length) { | |
while (k < coeff.length - 1) { | |
sum += coeff[k] * Math.pow(x, j); | |
k++; | |
j--; | |
} | |
wertetabelle[i] = sum + coeff[k]; | |
if (wertetabelle[0] > 0) { | |
System.out.println("... Unrelevant, denn dieses Polynom besitzt keine Nullstelle."); | |
break; | |
} | |
else if (wertetabelle[i] == 0) { | |
System.out.println("--------------------------------------------------------------"); | |
System.out.println("!--- Es wurde eine Nullstelle bei x = " + x + " gefunden! ---!"); | |
System.out.println("--------------------------------------------------------------"); | |
} | |
else if (wertetabelle[i] > 0 && grenze[0] == 6 && grenze[1] == 6) { | |
grenze[0] = x - 1; | |
grenze[1] = x; | |
} | |
System.out.print("(" + wertetabelle[i] + ") "); | |
i++; | |
x++; | |
k = 0; | |
j = coeff.length - 1; | |
sum = 0; | |
} | |
if (grenze[0] != 6 && grenze[1] != 6) { | |
System.out.println(); | |
System.out.println(); | |
System.out.println("Die Nullstelle liegt irgendwo zwischen " + grenze[0] + " und " + grenze[1]); | |
//3. Schritt: Nun wird der Wert von grenze, der dichter an 0 liegt, ueber mehrere | |
//Iterationsschritte in die Formel eingefuegt, um die Nullstelle naeherungsweise | |
//zu bestimmen | |
double wert; | |
if (Math.abs(grenze[1]) > Math.abs(grenze[0])) { | |
wert = grenze[0]; | |
} | |
else { | |
wert = grenze[1]; | |
} | |
System.out.println(); | |
System.out.println(); | |
System.out.println("Einzusetzender Wert wurde auf " + wert + " festgelegt."); | |
System.out.println(); | |
double nullstelle = 0; | |
//Nullstelle = wert - (/*wert eingesetzt in Ausgangspolynom*/ / /*Wert eingesetzt in 1. Ableitung*/); | |
//-> ueber mehrere Iterationsschritte (Newton-Verfahren) | |
k = 0; | |
/*double zaehler = 0; | |
double nenner = 0; | |
i = 0; | |
j = coeff.length - 1;*/ | |
while (k != 10) { | |
i = 0; | |
j = coeff.length - 1; | |
double zaehler = 0; | |
double nenner = 0; | |
while (i != coeff.length - 1) { | |
zaehler += coeff[i] * Math.pow(wert, j); | |
//System.out.println("Zaehler Rechnung: " + coeff[i] + " * (" + wert + "^" + j + ") = " + (coeff[i] * Math.pow(wert, j))); | |
i++; | |
j--; | |
} | |
zaehler += coeff[i]; | |
i = 0; | |
j = ableitung.length - 1; | |
while (i != ableitung.length - 1) { | |
nenner += ableitung[i] * Math.pow(wert, j); | |
//System.out.println("Nenner Rechnung: " + ableitung[i] + " * (" + wert + "^" + j + ") = " + (ableitung[i] * Math.pow(wert, j))); | |
i++; | |
j--; | |
} | |
nenner += ableitung[i]; | |
nullstelle = wert - (zaehler / nenner); | |
//System.out.println("Nullstelle Rechnung: " + wert + " - (" + zaehler + " / " + nenner + ") = " + nullstelle); | |
wert = nullstelle; | |
System.out.println("Nullstelle (Iteration #" + (k+1) + "): " + nullstelle); | |
k++; | |
} | |
System.out.println(); | |
System.out.println("Die Nullstelle liegt naeherungsweise bei " + nullstelle); | |
System.out.println(); | |
} | |
} //Ende newton | |
protected void add() { | |
//Addition des Polynoms mit sich selbst | |
while (true) { | |
try { | |
int[] summe; | |
summe = new int[coeff.length + 1]; | |
int i = 0; | |
while (i != coeff.length) { | |
summe[i] = (coeff[i] * 2); | |
i++; | |
} | |
int j = coeff.length; | |
System.out.println(); | |
System.out.println("Die Addition des Polynoms mit sich selbst ergibt: "); | |
for (i = 0; i != coeff.length; i++) { | |
if (j-1 == 0) { | |
System.out.print(summe[i]); | |
break; | |
} | |
else { | |
System.out.print(summe[i] + "x^" + (j-1) + " + "); | |
j--; | |
} | |
} | |
break; | |
} | |
catch (NullPointerException e) { | |
System.out.println("Fehler - Null Pointer Exception: " + e.getMessage()); | |
break; | |
} | |
} | |
} //Ende add | |
protected void print() { | |
//Gibt das Polynom auf die Konsole aus | |
int i = 0; | |
int j = 0; | |
while(true) { | |
try { | |
j = coeff.length; | |
System.out.println("Das generierte Polynom lautet: "); | |
while (i != coeff.length) { | |
if (j-1 == 0) { | |
System.out.print(coeff[i]); | |
break; | |
} | |
System.out.print(coeff[i] + "x^" + (j-1) + " + "); | |
i++; | |
j--; | |
} | |
break; | |
} | |
catch(NullPointerException e) { | |
System.out.println("Error - Null Pointer Exception: " + e.getMessage()); | |
break; | |
} | |
} | |
} //Ende print | |
public static void main(String [] args) throws Exception { | |
//Main-Funktion | |
BufferedReader keyboard = new BufferedReader(new InputStreamReader(System.in)); | |
int n = 0; | |
int auswahl = 100; //"Dummy-Wert" | |
System.out.println(); | |
System.out.println("Polynom.java - Hausaufgabe 4"); | |
System.out.println("****************************"); | |
System.out.println(); | |
while (true) { | |
try { | |
System.out.print("Geben Sie die gewuenschte Gradzahl des Polynoms an: "); | |
n = Integer.parseInt(keyboard.readLine()); | |
while (n < 0) { | |
System.out.print("Grad muss >= 0 sein! Bitte erneut eingeben: "); | |
n = Integer.parseInt(keyboard.readLine()); | |
} | |
break; | |
} | |
catch (NumberFormatException e) { | |
System.out.println("Fehler - Number Format Exception bei Eingabe: " + e.getMessage()); | |
} | |
} | |
Polynom p = new Polynom(n); | |
System.out.println(); | |
p.print(); | |
while (auswahl != 0) { | |
System.out.println(); | |
System.out.println(); | |
System.out.println(" Menue"); | |
System.out.println(" ---------------------------"); | |
System.out.println(" [1] Funktionswert berechnen"); | |
System.out.println(" [2] Nullstelle berechnen"); | |
System.out.println(" [3] Polynom mit sich selbst addieren"); | |
System.out.println(" [0] Ende"); | |
System.out.print(" Bitte treffen Sie eine Auswahl: "); | |
while (true) { | |
try { | |
auswahl = Integer.parseInt(keyboard.readLine()); | |
while (auswahl > 3 || auswahl < 0) { | |
System.out.print("Ungueltige Auswahl - bitte erneut eingeben: "); | |
auswahl = Integer.parseInt(keyboard.readLine()); | |
} | |
break; | |
} | |
catch (NumberFormatException e) { | |
System.out.println("Fehler - Number Format Exception bei Eingabe: " + e.getMessage()); | |
auswahl = 100; //"Dummy-Wert" | |
break; | |
} | |
} | |
if (auswahl == 1) { | |
System.out.println(); | |
System.out.println(); | |
System.out.print("Fuer welches Argument soll der Funktionswert berechnet werden?: "); | |
int x = 0; | |
while (true) { | |
try { | |
x = Integer.parseInt(keyboard.readLine()); | |
p.fktWert(x); | |
break; | |
} | |
catch (NumberFormatException e) { | |
System.out.println("Fehler - Number Format Exception bei Eingabe: " + e.getMessage()); | |
break; | |
} | |
} | |
} | |
if (auswahl == 2) { | |
if (p.grad <= 2) { | |
System.out.println(); | |
System.out.println("Fuer Polynome 2. Grades oder kleiner existieren in diesem Programm keine Nullstellen!"); | |
//...da das letzte konstante Glied des Polynoms immer positiv ist - siehe Konstruktor. | |
//Dieser if-switch ist noetig, da sonst der Weg ueber grenze[0] und [1] nicht funktioniert. | |
//-> siehe p.newton | |
} | |
else { | |
p.newton(); | |
} | |
} | |
if (auswahl == 3) { | |
p.add(); | |
} | |
} | |
System.out.println(); | |
System.out.println(); | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment