Mathematikorientierte Computernutzung, Sommersemester 2009
Eine Java-Klasse "Polynom"
M. Roczen
Das in der Vorlesung diskutierte Beispiel eignet sich als Grundlage zur Lösung der aktuellen Aufgabenserie 11,
in der eine ähnliche Struktur behandelt wird. Beachten Sie, dass eine rein formale Übernahme des Codes aus dieser
Seite die Aufgabe nicht löst.
Java-Quelltext
/* Polynom.java
Hier werden erste, aber längst nicht alle interessanten Eigenschaften
von Polynomen implementiert. Die Gewichte ( Weight, TotalWeight )
sind eher von didaktischer Bedeutung; sie sollen messen, wie ungünstig
die im konkreten Fall gewählten Koeffizienten unserer Polynome sind. */
class Polynom {
// Konstruktoren:
public Polynom() { int[ ] intlist = new int[0]; this.Coeffs = intlist; this.Weight=0; }
public Polynom( int[ ] a ) { this.Coeffs = a;
this.Weight = 0; int l = a.length;
for ( int i = 0; i < l; i++ ) { this.Weight += a[i]*a[i]; }
TotalWeight= TotalWeight + this.Weight; }
// Destruktor
protected void finalize() { TotalWeight -= this.Weight; }
// Instanzmethoden:
public int deg() { int deg = -1; int ll = Coeffs.length; for ( int i=0; i < ll; i++ ) { if ( Coeffs[i] != 0 ) { deg = i;} } return(deg); }
public Polynom multiply( Polynom g ) {
Polynom a = new Polynom();
if( this.deg() > -1 && g.deg() > -1 ) {
int r = this.Coeffs.length;
int s = g.Coeffs.length;
a.Coeffs = new int[r+s];
int i, j;
for ( i=0; i <= r-1; i++) {
for ( j=0; j<= s-1; j++ ) { a.Coeffs[i+j] += this.Coeffs[i]*g.Coeffs[j]; } }
}
return(a);
}
// Instanzvariablen:
int[ ] Coeffs;
int Weight;
// Klassenvariable
static int TotalWeight;
// Klassenmethode
static int getTotalWeight() { return( TotalWeight ); }
}
-
Achtung:
Dieses Programm lässt sich zwar kompilieren, es "tut aber nichts".
Ohne eine "main"-Anweisung hat ein Java-Programm keine Ausgabe!
-
Es ist eine kleine Überlegung wert, ob das obige Programm inhaltlich korrekt ist.
Die Methode multiply() soll offensichtlich mittels f.multiply(g) ein neues Polynom
(das Produkt von f und g) erzeugen.
Ist das so korrekt definiert? Es geht offenbar darum ob der Begriff "Polynom", so wie
wir ihn kennen, dasselbe beinhaltet wie die obige Implementierung.
-
Garnicht behandelt ist hier die Frage, wann zwei Polynome gleich sind. Kann
das mit equals() entschieden werden?
-
Die Fehlersuche in Java-Programmen ist eine durchaus interessante Aufgabe, die uns noch beschäftigen wird.
Verfeinerung
Wir wollen eine der zuvor gestellten Aufgaben lösen: In der obigen Klasse Polynom
kann ein Vergleich von Polynomen f und g mittels f.equals(g) deshalb nicht funktionieren, weil
equals() alle Eigenschaften eines Objekts vergleicht, dazu gehören auch die Längen der
Koeffizientenfolgen f.Coeffs.length und g.Coeffs.length. Durch ( 1 , 1 ) und ( 1 , 1 , 0) muss aber
vernünftiger Weise dasselbe Polynom gegeben sein (es wird ja in der Algebra durch eine unendliche
Folge von Koeffizienten definiert, die fast alle 0 sind).
Dafür bietet Java eine Lösung: Die Methode equals() wird in unserer Klasse Polynom abgeändert;
zu dem Zweck fügen wir folgenden Code ein:
// weitere Instanzmethode, überschreibt die allgemeine Methode equals()
public int equals( Polynom g ) {
int flag = 0;
int d = this.deg();
if ( d == g.deg() ) {
flag=1;
for ( int i = 0; i <= d; i++ ) { if ( this.Coeffs[i] != g.Coeffs[i] ) { flag = 0; break; } }
}
return(flag);
}
Wir können nun durch Aufruf von f.equals(g) feststellen, ob die Polynome f und g gleich sind; dies ist genau dann der Fall,
wenn die Methode den Wert 1 zurückgibt.
Erste Anwendung der Klasse Polynom
/*
Hier wird die Klasse Polynom in einem lauffähigen
Programm aufgerufen. Die neue Klasse Beispiel enthält nur
statische Methoden. Es werden zwei Polynome multipliziert,
eins davon enthält auch zufällige Koeffizienten.
*/
class Beispiel {
// schreibt manches Polynom in brauchbarer Gestalt:
public static String writesomething( Polynom f ) {
int d = f.deg();
String s = "";
String t = "";
String u = "";
for ( int i = 0; i <= d; i++ ) {
if ( i == 1 ) { t = "X"; }
if ( i > 1 ) { t = "X^"+i; }
if ( i > 0 ) { u = "+"; }
s = s + u + f.Coeffs[i] + t;
}
return( s );
}
// führt das Programm aus:
public static void main(String[ ] args) {
int[ ] Koeff_f = { 1, 2, 2};
int[ ] Koeff_g = { 1, (int)( 2 + 3*Math.random() ), (int)( 3 + 3*Math.random() ) };
Polynom f = new Polynom( Koeff_f );
Polynom g = new Polynom( Koeff_g );
System.out.print ( " Ist f = " + writesomething( f ) +"\n" );
System.out.print ( " und g = " + writesomething( g ) + ", dann ergibt sich \n" );
System.out.print ( " f g = " + writesomething( f.multiply( g ) ) +"\n" );
System.out.print ( " als Produkt dieser Polynome. \n" );
}}
Nach Kompilieren der Quelltexte kann mit dem Aufruf java Beispiel
das Resultat auf dem Bildschirm angesehen werden.
Anmerkungen
-
Auf der obigen Liste von Fragen bleibt damit immer noch eine unbeantwortet. Tatsächlich gibt es einen Fehler in Polynom.java.
-
Im Literaturverzeichnis finden Sie weitere Hinweise. Für Fragen zu einigen Tricks stehen wir Ihnen in der Übung zur Verfügung.
Marko Roczen, 13.7.2009