/* Aufgabe 16 - Funktionen : L O T T O

/* Aufgabe 16
-
Funktionen
:
L O T T O
( N )
Der sogenannte Binomialkoeffizient
( K )
(lies N über K)
beschreibt, wieviele Möglichkeiten es gibt, aus N vorgegebenen
Elementen eine Teilmenge von K Elementen auszuwählen.
Z.B. gibt es 5 über 3 Kombinationsmöglichkeiten,
3 "Richtige" aus einer Gruppe von 5 Zahlen auszuwählen.
N über K ist definiert als
N! / ( K! * (N-K)! ).
Dabei steht "X!" für die Fakultät von X, also für 1*2*3*...*X.
...
*/
public class l16
{
public static void main( String args[] )
{
System.out.println( "Lotto-Moeglichkeiten : " + binom( 49 , 6 ) ) ;
}
static double fak( int n )
{ int i ;
double f = 1.0 ;
for ( i=1 ; i<=n ; i++ )
f *= i ;
return f ;
}
static double binom( int N, int K )
{
return fak( N ) / ( fak( K ) * fak( N-K ) ) ;
}
}
/* Aufgabe 17 - Sortieren / Funktion mit Array als Referenzparameter
Schreiben Sie eine Funktion sort, die ein als Parameter übergebenes Array
von Zahlen der Größe nach sortiert.
In der Main-Funktion sollen Sie das Array mit Werten vorbesetzen,
ihre Funktion sort aufrufen und das sortierte Array ausgeben.
*/
public class l17
{
public static void main( String[] args )
{
int[] a1= {1,3,5,2,3,4,6} ;
int i1 ;
sort( a1 ) ;
for ( i1=0 ; i1 < 7 ; i1++ )
System.out.println(a1[i1]) ;
}
// hier startet das Programm
static void sort( int[] l1 )
// hier gibt es ganz viele
{ int index , laenge , tauschwert ;
// verschiedene Lösungen
for ( laenge = l1.length ; laenge > 0 ; laenge -- )
for ( index = 1 ; index < laenge ; index ++ )
if ( l1[index] < l1[index-1] )
{ tauschwert = l1[index] ;
l1[index] = l1[index-1] ;
l1[index-1] = tauschwert ;
}
}
}
Musterlösungen Seite 1 von 12
/* Aufgabe 18 : Pallindrome
18.1. Schreiben Sie ein Programm, das einen (in der main-Funktion
gegebenen) String rückwärts ausgibt.
Hinweis: wenn s ein String ist, liefert s.charAt(0) den 1. Buchstaben
und s.lenght() die Länge des Strings
18.2. Ein Pallindrom ist ein Wort, das von vorne und von hinten
gelesen gleich lautet.
Schreiben Sie eine Funktion, die testet und zurückgibt,
ob ein als Parameter übergebener String ein Pallindrom ist.
Ihre main-Funktion soll diese Funktion mehrfach (mit verschiedenen
Teststrings) aufrufen und jeweils das Ergebnis (ist oder ist kein
Pallindrom) ausgeben.
*/
public class l18 // pallindrom
{
public static void main( String[] args )
{
String p = "otto" ;
System.out.println( pal(p) ) ;
String p2 = "otito" ;
System.out.println( pal(p2) ) ;
String p3 = "abcda" ;
System.out.println( pal(p3) ) ;
String p4 = "abccda" ;
System.out.println( pal(p4) ) ;
}
// hier startet das Programm
static boolean pal( String s )
// gibt true oder false zurück
{
int i1 , l = s.length() ;
boolean pali = true ;
// bisher kein Unterschied da
for ( i1=0 ; i1 < l/2 ; i1++ )
if ( s.charAt(i1) != s.charAt(l-i1-1) )
pali = false ;
// ein Unterschied genügt !
return pali ;
}
}
/* Aufgabe A19 : Polygone
(mit Arrays)
A19.1. Die X-Koordinaten und die Y-koordinaten eines Polygons sollen Punkt
für Punkt in zwei Arrays X und Y in der main-Funktion festgelegt
werden. Sie dürfen annehmen, daß beide Arrays X und Y gleich
lang sind.
Schreiben Sie eine Funktion, die jeweils aus den X- und Y-Koordinaten
zweier Punkte (also ohne das ganze Polygon zu sehen)
den Punkteabstand berechnet und eine main-Funktion,
die mit Hilfe Ihrer Funktion den Polygonumfang berechnet.
A19.2. Ändern Sie Ihr Programm so, daß es die Polygonfläche berechnet.
Wenn (X0,Y0) , (X1,Y1) , (X2,Y2) , ... , (Xn,Yn) , (X0,Y0)
die Eckpunkte des Polygons sind (der n+1-te Punkt ist gleich
dem 0-ten), dann lautet die Formel für die Fläche:
(X0*Y1-Y0*X1)/2 + (X1*Y2-Y1*X2)/2 + (X2*Y3-Y2*X3)/2 + ... + (Xn*Y0-X0*Yn)/2
Der Betrag
Vorzeichen
eingegeben
eingegeben
dieser Formel berechnet den Flächeninhalt; das
ist positiv, wenn die Punktfolge gegen den Uhrzeigersinn
wurde, und negativ wenn die Punkte im Uhrzeigersinn
wurden.
*/
Musterlösungen Seite 2 von 12
public class l19 // Polygonumfang und -fläche
{
public static void main( String[] args )
// hier startet das Programm
{
double umfang = 0.0 ;
// 19.1
double flaeche = 0.0 ;
// 19.2
int ecke ;
double[] X = { 0, 3, 0 } ;
double[] Y = { 0, 0, 4 } ;
for ( ecke=1 ; ecke < X.length ; ecke++ )
{
umfang += abstand( X[ecke-1], Y[ecke-1], X[ecke], Y[ecke] ) ;
flaeche += areal( X[ecke-1], Y[ecke-1], X[ecke], Y[ecke] ) ;
}
umfang += abstand( X[0], Y[0], X[X.length-1], Y[X.length-1] ) ;
flaeche += areal( X[0], Y[0], X[X.length-1], Y[X.length-1] ) ;
System.out.println( "Der Umfang ist " + umfang ) ;
System.out.println( "Die Fläche ist " + flaeche ) ;
// 19.1
// 19.2
// 19.1
// 19.2
}
static double abstand( double p1x, double p1y, double p2x, double p2y )
{
return Math.sqrt( (p1x-p2x)*(p1x-p2x) + (p1y-p2y)*(p1y-p2y) ) ;
}
static double areal( double p1x, double p1y, double p2x, double p2y )
{
return ( p1x * p2y - p1y * p2x ) / 2 ;
}
}
/* Aufgabe 20 Polygone mit class punkt
20.1.
Lösen Sie die Aufgabe 19.1. (Berechnung des Polygonumfangs
und Berechnung der Polygonfläche) mit einer Klasse punkt.
Ihre main-Funktion soll eine Reihe von Polygon-Eckpunkten
definieren, z.B. durch
punkt[] polygon = { new punkt(0,4) new punkt(3,0) , new punkt(0,0) } ;
die main-Funktion soll das Polygon automatisch schließen,
d.h., die main-Funktion soll aus der Array-Länge polygon.length
die Eckenanzahl ermitteln und entsprechend oft eine Funktion abstand
Aufrufen. Ihre Funktion abstand soll hier (zur Übung) 2 Parameter
vom Typ punkt bekommen. (Es geht später noch eleganter.)
20.2.
Erweitern Sie Ihre main-Funktion so, daß sie berechnet,
welche beiden Punkte zueinander am nächsten sind und den Punktabstand
ausgibt (die Kordinaten der Punkte sollen nicht mit ausgegeben werden)
*/
class punkt
{
public double x , y ;
public punkt(double a,double b){ x=a ; y=b; }
}
Musterlösungen Seite 3 von 12
public class l20
// Polygon mit class punkt
{
public static void main( String[] args )
// hier startet das Programm
{
double umfang = 0.0 ;
int ecke ;
punkt[] polygon = { new punkt(0,4) , new punkt(3,0) , new punkt(0,0) } ;
for ( ecke=1 ; ecke < polygon.length ; ecke++ )
umfang += abstand( polygon[ecke-1], polygon[ecke] ) ;
umfang += abstand( polygon[polygon.length-1], polygon[0] ) ;
System.out.println( "Der Umfang ist " + umfang ) ;
// 20.2.
double minabstand = abstand( polygon[0] , polygon[1] ) ;
int ecke2 ;
for ( ecke=2 ; ecke < polygon.length ; ecke++ )
for ( ecke2=0 ; ecke2 < ecke ; ecke2++ )
if ( abstand( polygon[ecke] , polygon[ecke2] ) < minabstand )
minabstand = abstand( polygon[ecke] , polygon[ecke2] ) ;
System.out.println( "minimaler Punktabstand ist " + minabstand ) ;
}
static double abstand( punkt p1 , punkt p2 )
{
return( Math.sqrt( (p1.x-p2.x)*(p1.x-p2.x) + (p1.y-p2.y)*(p1.y-p2.y) ) ) ;
}
}
/* Aufgabe
21 :
Vererbung und Aggregation
21.1. Schreiben Sie ein Programm mit zwei Klassen (punkt und farbpunkt)
und einer Klasse a21 für die main-Funktion. Farbpunkt soll
eine Unterklasse von punkt sein und zusätzlich ein int-Attribut
für die Farbe enthalten (die int-Werte betragen z.B.
0 für schwarz, 1 für gelb , ..., 15 für weiß).
Beide Klassen sollen einen Konstruktor erhalten, mit dem alle
ihre Attribute gesetzt werden können, und eine Funktion zeige,
die alle Attributwerte ausgibt.
Ihre Klasse punkt soll eine Funktion zum Verschieben eines Punktes
um delta_X und delta_Y enthalten,
Ihre Klasse farbpunkt soll eine Funktion anbieten, mit der die Farbe
eines Punktes auf einen anderen int-Wert gesetzt werden kann.
Ihre main-Funktion soll einen Punkt und einen Farbpunkt definieren,
beide um (3,7) verschieben und anschließend die Daten beider Punkte
zur Kontrolle ausgeben.
21.2. Ergänzen Sie (zu der Klasse punkt aus 21.1.) eine Klasse Dreieck
mit einem Konstruktor, der die Eckpunkte eines Dreiecks setzt,
einer Funktion zeige, die die Koordinaten aller 3 Ecken zeigt
und einer Funktion verschiebe, die das ganze Dreieck um
delta_X, delta_Y verschiebt.
Hinweis: Das Dreieck soll aus 3 Eckpunkten bestehen, d.h., es
soll die Klasse Punkt als Attributtyp verwenden, nicht von ihr erben!
In Ihrer main-Funktion sollen Sie zu Testzwecken ein Dreieck
definieren, verschieben und seine Koordinaten anzeigen lassen.
*/
Musterlösungen Seite 4 von 12
class punkt
{
public double x , y ;
public punkt(double a,double b){ x=a ; y=b; }
public void move(double delta_X,double delta_Y){ x+=delta_X ; y+=delta_Y; }
public void zeige() { System.out.println( "(" + x + "," + y + ")" ) ; }
}
class farbpunkt extends punkt
{
public int farbe ;
public farbpunkt( double a, double b, int f ) { super(a,b); farbe = f ; }
public void setzeFarbe( int neu ) { farbe = neu ; }
public void zeige() {
System.out.print( "Farbnr " + farbe + " : " ) ;
super.zeige() ;
}
}
class dreieck
//a21.2
{ public punkt a,b,c ;
public dreieck( punkt p1,punkt p2,punkt p3 ) { a=p1 ; b=p2 ; c=p3 ; }
public void move( double delta_X, double delta_Y )
{ a.move(delta_X,delta_Y) ;
b.move(delta_X,delta_Y) ;
c.move(delta_X,delta_Y) ;
}
public void zeige() { System.out.println( "Dreieck:") ;
a.zeige(); b.zeige() ; c.zeige() ;
}
}
public class l21
{
public static void main( String[] args )
{
punkt p1 = new punkt(30,40) ;
farbpunkt fp2 = new farbpunkt(60,80,15) ;
p1.move(3,7) ;
fp2.move(3,7) ;
p1.zeige() ;
fp2.zeige() ;
// hier startet das Programm
dreieck d3 = new dreieck( new punkt(10,20), new punkt(30,40),
new punkt(50,60) ) ;
d3.move(2,3) ;
d3.zeige() ;
//a21.2
//a21.2
//a21.2
//a21.2
}
}
Musterlösungen Seite 5 von 12
/* Aufgabe 23 : Dateien und Tastatureingabe
23.1. Legen Sie eine Datei "f1.txt" in Ihrem aktuellen Verzeichnis
mit folgendem Inhalt an:
7
56
173
abc7def
ijk
Kopieren Sie das anliegende Programm und lassen es laufen.
Erweitern bzw. verändern Sie das Programm so, daß es die
Dateigröße Ihrer Datei f1.txt (incl. Leer- und Sonderzeichen)
ausgibt.
23.2. Schreibstil von Journalisten
Erweitern Sie Ihr Programm so, daá es z„hlt, wieviele Ausrufezeichen
und wieviele Punkte in dem Text vorkommen.
Wenn mindestes soviele Punkte wie Ausrufezeichen im Text vorkommen,
soll Ihr Programm melden: "Das ist ein normaler Text".
Wenn aber mehr Ausrufezeichen als Punkte im Text vorkommen,
soll Ihr Programm sagen "Das ist ja BILD-Stil !"
Ändern Sie die Eingabedatei entsprechend ab und testen Sie
verschiedene Eingabetexte.
23.3. Buchstabenhäufigkeiten
Die Verk„ufer des Spieles Scrabble wollen Ihr Spiel jetzt auch in den
osteurop„ischen L„ndern vertreiben. Um die Spielchancen ausgewogen zu
gestalten, ben”tigen Sie dringend ein Programm, das die H„ufigkeiten
von Buchstaben in vorgegebenen Textdateien z„hlt und ausgibt. Helfen Sie
den armen Spieleverk„ufern mit einem Programm, das die H„ufigkeiten
aller Buchstaben ausgibt.
Hinweis: Beschränken Sie sich zur Vereinfachung in Ihrem Eingabetext
auf die Buchstaben 'A' bis 'Z' und ignorieren Sie
Kleinbuchstaben und Umlaute.
Sie k”nnen Ihr Programm A23.2 erweitern.
23.4. Erweitern Sie Ihr Programm aus 23.2 oder 23.3 so, daß es Sie
nach dem Namen der Eingabedatei fragt, d.h., daß Sie den Namen
der Eingabedatei an der Tastatur eingeben können.
*/
Musterlösungen Seite 6 von 12
import java.io.* ;
public class l23
{
public static void main( String[] args )
// hier startet das Programm
{ try
{ System.out.println( "Welche Datei soll ich analysieren?" );
// 23.4
BufferedReader ein1 = new BufferedReader(
// 23.4
new InputStreamReader(System.in) ) ;
// 23.4
String s1 = ein1.readLine() ;
// 23.4
FileInputStream is = new FileInputStream( s1 ) ;
// 23.4
// 23.1-23.3 nur:
FileInputStream is = new FileInputStream( "f1.txt" ) ;
BufferedReader ein = new BufferedReader( new InputStreamReader (is) ) ;
String s = ein.readLine() ;
int zeichenanzahl = 0 ;
int punktanzahl = 0 ;
int ausrufezeichen = 0 ;
int[] anzahl = new int[256] ;
char zeichen ;
while (s != null)
{ // Zeile verarbeiten - hier:
for (int i=0; i<s.length(); i++)
{ zeichenanzahl ++ ;
zeichen = s.charAt(i) ;
if ( zeichen == '.' ) punktanzahl ++ ;
if ( zeichen == '!' ) ausrufezeichen ++ ;
if ( zeichen >= 'a' && zeichen <='z' )
anzahl[ zeichen ] ++ ;
//
//
//
//
23.1
23.2.
23.2.
23.3.
//
//
//
//
23.1
23.2+3
23.2
23.2
// 23.3
}
zeichenanzahl += 2 ;
s = ein.readLine();
// für CR und LF (Zeilenende) // 23.1
// nächste Zeile holen
}
ein.close() ; // Eingabedatei schließen - entfällt bei System.in
System.out.println( zeichenanzahl + " Zeichen in der Datei" ) ;
// 23.1
if ( punktanzahl >= ausrufezeichen )
System.out.println( "Normaler Text" ) ;
else System.out.println( "Das ist ja Bild-Stil" ) ;
// 23.2
for( zeichen = 'a' ; zeichen <= 'p' ; zeichen ++ )
{
System.out.println( "Buchstabe " + zeichen + " gibt es " +
anzahl[zeichen] + " mal" ) ;
}
// 23.3
}
catch (Exception e) { System.out.println(e) ; } // Ausnahmebehandlung
}
}
/* Aufgabe 24/25: Schadstoffmeßreihe:
Ein Umweltforschungsinstitut hat zu verschiedenen Tageszeiten Luftproben
ausgewertet und unter anderem den Kohlenmonoxid-Gehalt bestimmt.
Die Kohlenmonoxid-Anteile sollen (einer pro Zeile) über die Tastutur
eingegeben werden, und die Eingabe wird durch Eingabe eines negativen
Wertes abgeschlossen.
Für weitere Arbeiten braucht das Institut dringend folgende Programme:
Musterlösungen Seite 7 von 12
24.1. Ein Programm soll aus den eingegebenen Werten den größten und den
kleinsten Kohlenmonoxid-Anteil und den Mittelwert berechnen und
auf dem Bildschirm ausgeben.
24.2. Erweitern Sie das Programm so, daß es die am Bildschirm eingegeben
Zahlen in einer Datei abspeichert (einen Wert pro Zeile).
Der Benutzer soll den Dateinamen frei wählen können, indem er ihn
an der Tastatur eingibt.
Sehen Sie sich zur Kontrolle den Inhalt der erzeugten Datei auf dem
Bildschirm an.
Aufgabe 25: Eigene Dateien lesen:
25.
Schreiben Sie ein neues Programm (eine neue Datei a25.java),
das die von Aufgabe 24.2. geschriebene Datei liest und die
gespeicherten Werte (einen Wert pro Zeile) am Bildschirm ausgibt.
*/
import java.io.* ;
public class l24
{
public static void main( String[] args )
// hier startet das Programm
{ try
{ System.out.println( "In welche Datei soll ich schreiben?" );
// 24.2
BufferedReader ein = new BufferedReader(
// 24.2
new InputStreamReader(System.in) ) ;
// 24.2
String s = ein.readLine() ;
// 24.2
FileOutputStream os = new FileOutputStream( "f1.out" ) ;
// 24.2
PrintWriter aus = new PrintWriter( new OutputStreamWriter (os) ) ; // 24.2
double summe = 0 , wert ,
min = 100.0 , max = 0.0 ;
int wertanzahl = 0 ;
// Anteile zwischen 0 und 100 %
try
{
System.out.println( "Bitte CO-Gehalt eingeben " +
" ( Abbruch mit negativem Wert )" );
s = ein.readLine() ;
wert = (new Double(s)).doubleValue() ;
while ( wert>= 0 )
{
if ( wert<min ) min = wert ;
if ( wert>max ) max = wert ;
wertanzahl ++ ;
summe += wert ;
aus.println(s) ;
// 24.2
System.out.println( "Bitte CO-Gehalt eingeben " +
" ( Abbruch mit negativem Wert )" );
s = ein.readLine() ;
wert = (new Double(s)).doubleValue() ;
}
} catch (Exception e) { System.out.println(e) ; } // Ausnahmebehandlung
aus.close() ;
if ( wertanzahl>0 )
{ System.out.println( "Mittelwert : " + summe/wertanzahl ) ;
System.out.println( "Minimum : " + min ) ;
System.out.println( "Maximum : " + max ) ;
}
else System.out.println( "keinen Wert eingegeben" ) ;
}
catch (Exception e) { System.out.println(e) ; } // Ausnahmebehandlung
}
}
Musterlösungen Seite 8 von 12
/* Aufgabe 24/25: Schadstoffmeßreihe:
Ein Umweltforschungsinstitut hat zu verschiedenen Tageszeiten Luftproben
ausgewertet und unter anderem den Kohlenmonoxid-Gehalt bestimmt.
Die Kohlenmonoxid-Anteile sollen (einer pro Zeile) über die Tastutur
eingegeben werden, und die Eingabe wird durch Eingabe eines negativen
Wertes abgeschlossen.
Für weitere Arbeiten braucht das Institut dringend folgende Programme:
24.1. Ein Programm soll aus den eingegebenen Werten den größten und den
kleinsten Kohlenmonoxid-Anteil und den Mittelwert berechnen und
auf dem Bildschirm ausgeben.
24.2. Erweitern Sie das Programm so, daß es die am Bildschirm eingegeben
Zahlen in einer Datei abspeichert (einen Wert pro Zeile).
Der Benutzer soll den Dateinamen frei wählen können, indem er ihn
an der Tastatur eingibt.
Sehen Sie sich zur Kontrolle den Inhalt der erzeugten Datei auf dem
Bildschirm an.
Aufgabe 25: Eigene Dateien lesen:
25.
Schreiben Sie ein neues Programm (eine neue Datei a25.java),
das die von Aufgabe 24.2. geschriebene Datei liest und die
gespeicherten Werte (einen Wert pro Zeile) am Bildschirm ausgibt.
*/
import java.io.* ;
public class l25
{
public static void main( String[] args )
// hier startet das Programm
{ try
{ System.out.println( "Welche Datei soll ich analysieren?" );
BufferedReader ein1 = new BufferedReader(
new InputStreamReader(System.in) ) ;
String s1 = ein1.readLine() ;
FileInputStream is = new FileInputStream( s1 ) ;
BufferedReader ein = new BufferedReader(
new InputStreamReader (is) ) ;
try
{
String s = ein.readLine() ;
while (s != null)
{ // Zeile verarbeiten - hier:
System.out.println( s ) ;
s = ein.readLine();
// nächste Zeile holen
}
}
catch (Exception e) { System.out.println(e) ; } // Ausnahmebehandlung
ein.close() ; // Eingabedatei schließen
}
catch (Exception e) { System.out.println(e) ; } // Ausnahmebehandlung
}
}
Musterlösungen Seite 9 von 12
/* Aufgaben 26 und 27 (Funktionsobjekten als Parameter in Funktionen):
A26: Nullstelle allgemein / Schnittpunkte von Funktionen
26.1. Schreiben Sie eine Funktion Nullstelle, die die Nullstelle von beliebigen
Funktions-Objekten berechnet (z.B. die Nullstelle vom Tangens zwischen
3 und 4, oder die Nullstelle vom Cotangens zwischen 1 und 2).
Sie können dazu Ihre Lösung zur Aufgabe 15 verallgemeinern.
Ihre Funktion Nullstelle soll ein Objekt der Klasse function
als Parameter haben, d.h. man soll ihr ein beliebiges function-Objekt
als Parameter übergeben können (z.B. Tangens) und Startwerte
für die Intervallhalbierung.
Testen Sie Ihre Nullstellenfunktion, indem sie u.a. die Nullstelle
des Tangens im Intervall [6,7] ,
des Tangens im Intervall [3,4] ,
des Tangens im Intervall [-0.5,1.5]
und
des Cotangens im Intervall [1,2]
Cotangens(x)=cos(x)/sin(x)
von Ihrer Nullstellenfunktion berechnen und in der main-Funktion (!)
ausgeben lassen. (Dazu müssen Sie auch Tangens und Cotangens als
Unterklasse von function mit je einer run()-Methode programmieren.)
Sie sollen voraussetzen, daß man die Funktion Nullstelle von der
main-Funktion nur mit solchen function-Objekten und Intervallen aufruft,
für die es auch eine Nullstelle gibt, die durch Intervallschachtelung
gefunden werden kann.
26.2. Schreiben Sie eine Funktion Schnittpunkt, die (wie die Funktion
Nullstelle) durch Intervallschachtelung einen Schnittpunkt
von 2 als Parameter übergebenen function-Objekten berechnet.
Wie bei der Nullstellenfunktion sollen Sie voraussetzen, daß man die
Funktion Schnittpunkt im Hauptprogramm nur mit solchen
function-Objekten und Intervallen aufruft, für die es auch einen
Schnittpunkt gibt, der durch Intervallschachtelung gefunden werden kann.
26.3. (Zusatzaufgabe:)
Evtl. sind Ihre Funktionen Schnittpunkt und Nullstelle recht ähnlich
codiert. Wie kann man es vermeiden, die Intervallschachtelung doppelt
zu codieren ?
===========================================================================
27. Aufgabe : Numerisches Integrieren:
27.1. Schreiben Sie eine Funktion Integriere, die Ihnen das Integral der
Quadrat-Funktion x |-> x*x im jeweils übergebenen Intervall berechnet.
Ihre main-Funktion soll die Intervallgrenzen festlegen und das Ergebnis
Ihrer Funktion ausgeben.
Ihre Funktion Integriere soll Rechtecke aufsummieren: Die Grundseite
alle Rechtecke ist dx (z.B. dx = 0.1), die Höhe der Rechtecke ergibt
sich aus dem Funktionswert an der Stelle x.
Beispiel: Gesucht ist die Fläche unter der Parabel im Intervall
von 1 bis 2: Bei dx=0.1 hat das erste Rechteck die Höhe 1.0*1.0,
das nächste Rechteck hat die Höhe 1.1*1.1, usw.
Kontrollieren Sie, wie sich die Genauigkeit verbessert, wenn Sie
dx auf 0.01 und auf 0.001 setzen.
27.2. Verallgemeinern Sie Ihre Funktion Integriere so, daß sie beliebige
function-Objekte integrieren kann, und testen Sie diese
verallgemeinerte Funktion, indem Sie das Integral von x |-> x*x*x im
Intervall von 0 bis 1 und das Integral von x |-> sin(x) im Intervall
von 0 bis 3.14 berechnen.
(Dazu müssen Sie für Quadrat, Kubik und Sinus auch als je eine
Unterklasse von function programmieren)
Überprüfen Sie jeweils Ihre Ergebnisse !
*/
Musterlösungen Seite 10 von 12
class function
// nützlich für alternative Nullstellenberechnung
{
public double run(double x){ return 0; } ; // wird für Nullfunktion genutzt (s.u.)
}
class sinus extends function
{
public double run(double x){ return Math.sin(x) ; }
}
class cosinus extends function
{
public double run(double x){ return Math.cos(x) ; }
}
class differenz extends function
// nützlich für alternative Schnittberechnung
{ function F,G ;
public differenz( function f, function g ) { F=f ; G=g ; }
public double run(double x){ return F.run(x) - G.run(x) ; }
}
public class l26
{
public static void main( String[] args )
// hier startet das Programm
{ // FileInputStream is = new FileInputStream("t16.class") ;
// BufferedReader ein = new BufferedReader( new InputStreamReader( System.in )) ;
function f = new sinus() ;
function g = new cosinus() ;
final double Untergrenze = -1 ;
final double Obergrenze = 1 ;
System.out.println( "Die Nullstelle zwischen " + Untergrenze +
" und " + Obergrenze + " liegt bei " +
nullstelle( f , Untergrenze, Obergrenze ) ) ; //1. Lösung
System.out.println( "Die Nullstelle zwischen " + Untergrenze +
" und " + Obergrenze + " liegt bei " +
Nullstelle( f , Untergrenze, Obergrenze ) ) ; //Alternative
System.out.println( "Der Schnittpunkt zwischen " + Untergrenze +
" und " + Obergrenze + " liegt bei " +
Schnittstelle( f , g , Untergrenze, Obergrenze ) ) ; // 1.Lös.
System.out.println( "Der Schnittpunkt zwischen " + Untergrenze +
" und " + Obergrenze + " liegt bei " +
schnittstelle( f , g , Untergrenze, Obergrenze ) ) ; //Altern.
System.out.println( "Das Integral zwischen " + 0 +
" und " + Math.PI + " ist " +
integral( f , 0, Math.PI ) ) ;
} // hier ist die main-Funktion zuende
// die folgende Funktion berechnet die Nullstelle zwischen ug und og
// eine Alternative Implementierung s.u.
static double nullstelle( function f , double ug, double og )
{
// hier deklarieren Sie bei Bedarf lokale Variablen
final double epsilon = 0.0000001 ;
double m ;
do
{ m = (ug+og) / 2 ;
if ( f.run(ug) * f.run(m) <= 0 )
og = m ;
else ug = m ;
} while ( Math.abs(og-ug) > epsilon ) ;
return m ;
} // hier ist die Funktion nullstelle zuende
Musterlösungen Seite 11 von 12
// die folgende Funktion berechnet die Schnittstelle zwischen ug und og
// eine Alternative Implementierung s.u.
static double Schnittstelle( function f, function g, double ug, double og )
{
double epsilon = 0.0000001 ;
double m ;
do
{
m = (ug+og) / 2 ;
if ( ( f.run(ug)-g.run(ug) ) * ( f.run(m) - g.run(m) ) <= 0 )
og = m ;
else ug = m ;
} while ( Math.abs(og-ug) > epsilon ) ;
return m ;
} // hier ist die Funktion Schnittstelle zuende
// die folgende Funktion berechnet auch die Nullstelle zwischen ug und og
// alternative Implementierung – sofern Schnittstelle schon implementiert ist
static double Nullstelle( function f , double ug, double og )
{ function nullFunktion = new function() ;
return Schnittstelle( f , nullFunktion , ug , og ) ;
}
// die folgende Funktion berechnet auch die Schnittstelle zwischen ug und og
// alternative Implementierung – sofern nullstelle schon implementiert ist
static double schnittstelle( function f, function g, double ug, double og )
{ differenz d = new differenz(f,g) ;
return nullstelle( d , ug , og ) ;
}
// a27.2: Integral einer beliebigen Funktion
static double integral( function f, double ug, double og )
{ double step=(og-ug)/100 , flaeche = 0 ;
int i=0 ;
for( ; i<100 ; i++ )
{ flaeche += f.run(ug+i*step) * step ; }
return flaeche ;
}
}
Musterlösungen Seite 12 von 12