Universität Hamburg - Fachbereiche - Fachbereich Mathematik

Numerische Mathematik mit Java

Bodo Werner

Inhaltsverzeichnis

• Vorbemerkung
• Einführung



• Sprachelemente

• Kommentare (//, /* */)
• Anweisungen
• Bezeichner
• Blöcke ( {...})
• Variable und ihre Typen (double, int)
• Deklaration einer Variablen(double x=1.234;)
• Zeichenketten und Zeichen (String, char)
• Konstante (final)
• Operatoren (++, +=,... )
• Ein- und mehrdimensionale Felder (double[], double[][])
• for-Schleifen ( for(i=1;i<=n;i++){...})
• while-Schleifen
• if ( if (...) {...} else {...} )
• switch
• Ausgabe auf dem Bildschirm (System.out.println("Java ist cool"))



• Numerik-Beispiele ohne OOP

• Lösung eines linearen Gleichungssystems
• Berechnung eines Newtonschen Interpolationspolynoms



• Numerik-Beispiele mit einem Hauch von OOP

• Lösung eines linearen Gleichungssystems
• Berechnung eines Newtonschen Interpolationspolynoms



• Objektorientiertes Programmieren (OOP) (mit der Klasse Funktion und Unterklasse Polynom)

• Objektorientiertes Programmieren (OOP) (mit der Klasse Matrix und Unterklasse TridiagonalMatrix)

• Applets
• Eigene Klasse Tools

Vorbemerkung

Nun scheint es so, daß Pascal keine Zukunft hat. Mittelfristig muß man sich daher umorientieren. Das moderne Programmierungskonzept heißt Objektorientiertes Programmieren (OOP). Ich halte es für sehr sinnvoll, wenn Studierende von Beginn an mit diesem Konzept konfrontiert werden. Hierfür scheint mir Java hervorragend geeignet, weil es dieses Konzept verbindlich vorschreibt, einfacher zu erlernen sein soll als der mächtige(re) Vertreter C++ und plattformunabhängig ist. Daher soll in Hamburg im WiSe 99/00 erstmalig der Versuch unternommen werden, den zweisemestrigen Numerik-Kurs für Anfänger mit Java zu verknüpfen. Um Mißverständnissen vorzubeugen: nicht, weil ich glaube, daß Java in hervorragender Weise die Implementierung numerischer Algorithmen unterstützt, sondern weil mit Java eine sehr moderne Programmierrsprache erlernt wird, die das Tor zum OOP weit aufstößt. Ein weiterer Gesichtspunkt ist, daß das Erlernen von Java ein wichtiger Aspekt der Qualifikation für einen späteren Beruf darstellt - in viel höherem Maße als dies z.B. Pascal vermag.

Die große Popularität verdankt Java dem Internet und der Tatsache, daß Java-Applets von WWW-Browsern interpretiert werden können. Das zur Zeit beste (mathematische) Zeugnis der Mächtigkeit solcher Applets findet man meines Erachtens in der Mathe Online - Galerie

Der Einsatz von Java in der Erstsemster-Numerik soll sich aber nicht an Applets orientieren, sondern der Implementierung von grundlegenden numerischen Algorithmen dienen. Weder sollen Input-Output- noch Grafiktechniken Gegenstand des Unterrichts sein. Hierfür werden Klassen zur Verfügung gestellt werden, die auf den Numerikeinsatz zugeschnitten sind und als Black-Box benutzt werden.

Das hier angebotene Tutorium richtet sich an Studierende, aber auch an Kollegen. Es soll helfen, sich mit Java vertraut zu machen. Vorkenntnisse in Pascal, aber auch ein erstes Verständnis von OOP sind ausgesprochen hilfreich. Wiederholt wird auf Analogien bei Pascal hingewiesen. Dass die Sprachelemente vor einer Einführung in Objekte und Klassen zur Sprache kommen, bedeutet nicht, dass diese Reihenfolge beim Lernen eingehalten werden sollte. Anf&aumL,nger sollten möglichst bald mit dem Konzept des OOP konfrontiert werden. Das wird in den begleitenden Kursmaterialien versucht.

Man findet aber auch viele Dokumentationen und Tutorials im Web:

Der Autor ist alles andere als ein Profi in Sachen Programmiersprachen, insbesondere fehlt ihm der tiefer gehende Einblick in die Struktur von höheren Programmiersprachen. Er ist blutiger Anfänger in Sachen OOP und auch schon relativ alt. Er bittet daher, möglichen Ungereimtheiten, insbesondere in der Fachsprache, mit Nachsicht zu begegnen.

Einführung

Das Grundkonzept von Java beruht auf dem objektorientierten Programmieren (OOP). Ein Objekt ist eine (neuartige) Variable vom Typ einer Klasse , in Abgrenzung zu den primitiven (einfachen) Datentypen (Zahlen: int, double,..., logische Variable: boolean, Zeichen: char). Objekte werden durch ihre Attribute (Eigenschaften, Daten, Variable) und ihre Methoden (Verhalten) charakterisiert. OOP ist des weiteren durch die Möglichkeit der Bildung von Unterklassen mit Vererbung und Polymorphie gekennzeichnet. Dennoch sollen zunächst die sehr Pascal-verwandten Sprachelemente wie Datentypen, Verzweigungen, Schleifen behandelt werden. Wer dennoch sehr schnell ein lauffähiges Programm schreiben will, orientiere sich an der folgenden Variante des unvermeidlichen Hello World-Programms:

class Hallo{
 public static void main (String args[]) {
 System.out.println("Hallo: Ich kann noch nicht Java");
 }
}

Sprachelemente

Kommentare

class Hallo{  //class ist das wichtigste Schlüsselwort
/*
Man achte stets auf die Groß- und Kleinschreibung.
args ist ein Bezeichner für eine Stringvariable und kann auch durch
irgendetwas anderes ersetzt werden.
String und System als Bezeichner vordefinierter Klassen
werden groß, class und out dagegen klein geschrieben.
*/
 public static void main (String args[]) {
 System.out.println("Hallo: Ich kann immer noch nicht Java");
 }
}

Anweisungen

Bezeichner

Blöcke

Variable

Deklaration einer Variablen

String, char

Konstante

Operatoren

Vergleichsoperatoren sind == (im Gegensatz zu Pascal: =) für Gleichheit, != f"ur Ungleichgleichheit (Pascal <>), ansonsten <, <=, >, >= wie in Pascal.

Logische Operatoren werden in Pascal mit and, or, xor, not ausgeschrieben, in Java mit & (and), ! (not), | (or) und ^ (xor) abgekürzt.

Bitweise Operatoren werden hier nicht behandelt, da in der Numerik wohl unbedeutend.

Stringadditionen sind in Java sehr bequem:

String s="Hallo" + "  " + "Numerik-Freunde";

int anzahl=5;
String s="Hier sitzen "+anzahl+" Zuhörer";

Array

 String[] Wortliste = {"Frau","Mann","Kind"};

double[][] A={{1,2},{8,9}};

 Wortliste: Array[1..3] of String =("Frau","Mann","Kind");

Mehrdimensionale Arrays:
double[][] A; A = new double[4][6] erzeugt eine 4 x 6 -Matrix mit den Zeilen 0,1,2,3 und den Spalten 0,1,2,...,5. Bei einer solchen Initialisierung erhält A die Elemente Null. Das ist fehleranfällig! Einzelne Elemente werden mit A[i][j] angesprochen (Pascal: A[i,j]).

for-Schleifen

 for (i=1;i<=n;i++) for (j=1;j<=n;j++) A[i-1][j-1]=1/(i*j);
 

while-Schleifen

int i=1; while(i<=6) {System.out.println(i);i++;}

int i=1; do {System.out.println(i);i++;} while (i<=6);

if-Anweisung

 if (a<b) s="a ist kleiner als b";  else s="a >= b";

switch

char c;
switch(c)
{
case 'J':'j':
    //Java-Anweisungen
    break;
case 'N':'n':
    //Java-Anweisungen
    break;
default:
   //noch mehr Anweisungen
}

Ausgabe auf den Bildschirm:

System.out.println("Das Pivotelement der Matrix lautet:"+A[i][i]);

Numerik-Beispiele ohne OOP

Lösung eines linearen Gleichungssystems

class Matrix{
// METHODEN -----------------------------------------------------------
   static void LRZerlegung(int n, double[][] A){
    int i,j,k;
    for(k=0;k<n-1;k++)
     for(i=k+1;i<n;i++){
       A[i][k]/=A[k][k];
       for (j=k+1;j<n;j++)    A[i][j]-=A[i][k]*A[k][j];
     }//Ende for i
    }// Ende LRZerlegung()
   static double[] LoeseLGS(int n, double[][] A, double[] b){
     int i,j;
     LRZerlegung(n,A);
     //beginn vorwaertseinsetzen
     for(i=1;i<n;i++) for(j=0;j<i;j++)  b[i]-=A[i][j]*b[j];
     //ende Vorwaertseinsetzen
     //beginn rueckwaertseinsetzen
     for(i=n-1;i>=0;i--){
      for(j=n-1;j>i;j--) b[i]-=A[i][j]*b[j];
      b[i]/=A[i][i];
     }//ende Rueckwaertseinsetzen
     return b;
    }//ende LoeseLGS()
    static void main(String args[]){ //so faengt jedes Hauptprogramm an
      int n=3;
      double[] b={3.1, 3, 0};
      double[][] A={{2.1,-1, 1},{2, -4, 3},{-4, 8,-4}};
      b=LoeseLGS(n,A,b);
      System.out.println("Lösungsvektor:");
      for(int i=0;i<n;i++) System.out.println("x["+i+"]="+b[i]);
     }//ende main()
}// ende class Matrix

Berechnung eines Newtonschen Interpolationspolynoms

class NewtonPolynom{
//Variablen:
  static int Grad=3;
  static double[] x={1,2,3,4}; //Knoten
  static double[] y={1,4,9,16};//Werte
  static double[] c=new double[Grad+1]; //Div. Differenzen
//Methoden:
  static void DividierteDifferenzen(){
   for(int i=0;i<=Grad;i++) c[i]=y[i];
   for(int k=1;k<=Grad;k++)
   for(int i=Grad;i>=k;i--) c[i]=(c[i]-c[i-1])/(x[i]-x[i-k]);
  }//Ende DividierteDifferenzen()
  static double[] Horner(double xi){
   int j;
   double[] b = new double[Grad];
   DividierteDifferenzen();
   b[Grad-1]=c[Grad];
   for(j=Grad-2;j>=0;j--)  b[j]=c[j+1]+(xi-x[j+1])*b[j+1];
   return b;
  }//ende Horner()
  static double getWert(double xi){
   double[] b = new double[Grad];
   if (Grad==0) return c[0];
   else{
    b=Horner(xi);
    return b[0]*(xi-x[0])+c[0];
   }//Ende else
  }//Ende getWert()
  static void main(String[] args){
    System.out.println("Wert an der Stelle 1.1: "+getWert(1.1));
  }//Ende main()
}//ende class NewtonPolynom

Numerik-Beispiele mit einem Hauch OOP

Lösung eines linearen Gleichungssystems

class Matrix{
//DATEN (Variable) ---------------------------------------
   int n;  // Abmessung einer quadratischen Matrix
   double[][]  Data, LR;
          //Data: Elemente der Matrix, LR: nach der LR-Zerlegung
//KONSTRUKTOR ---------------------------------------------------------
   Matrix(int n){  //Konstruktor einer quadratischen Matrix
      int i;
      this.n=n;
      Data=new double[n][n];
      LR=new double[n][n];
   }//Ende Konstruktor
// METHODEN -----------------------------------------------------------
   LRZerlegung(){
    int i,j,k;
    for(i=0;i<n;i++) for(j=0;j<n;j++)  LR[i][j]=Data[i][j];
    //LR=Data bewirkt, dass in Folge LR=Data, d.h. Data veraendert wird.
    //Der Grund: LR und Data sind Referenzvariable
    for(k=0;k<n-1;k++)
     for(i=k+1;i<n;i++){
       LR[i][k]/=LR[k][k];
       for (j=k+1;j<n;j++)    LR[i][j]-=LR[i][k]*LR[k][j];
     }//Ende for
    }// Ende LRZerlegung()
    double[] LoeseLGS(double[] b){
     int i,j;
     LRZerlegung();
     //beginn vorwaertseinsetzen
     for(i=1;i<n;i++) for(j=0;j<i;j++)  b[i]-=LR[i][j]*b[j];
     //ende Vorwaertseinsetzen
     //beginn rueckwaertseinsetzen
     for(i=n-1;i>=0;i--){
      for(j=n-1;j>i;j--) b[i]-=LR[i][j]*b[j];
      b[i]/=LR[i][i];
     }//ende Rueckwaertseinsetzen
     return b;
    }//ende LoeseLGS()
     static void main(String args[]){ //so faengt jedes Hauptprogramm an
      int n=3;
      Matrix A=new Matrix(n);
      double[] b={3.1, 3, 0};
      double[][] a={{2.1,-1, 1},{2, -4, 3},{-4, 8,-4}};
      A.Data=a; //besser A.setData(a);
      b=A.LoeseLGS(b); //wird automatisch eine LR-Zerlegung gemacht
      System.out.println("Lösungsvektor:");
      for(int i=0;i<n;i++) System.out.println("x["+i+"]="+b[i]);
     }//ende main()
}// ende class Matrix

Berechnung eines Newtonschen Interpolationspolynoms

class NewtonPolynom{
//DATEN (Attribute, Mitgliedsvariable):
  int Grad;
  double x[]; //Knoten
  double y[]; //Werte
  double c[]; //Koeffizienten (p=c0+c1*(x-x0)+....+cn*(x-x0)*...(x-x_n-1)
//KONSTRUKTOR:
  NewtonPolynom(int Grad,double[] x, double[] y){
   this.Grad=Grad;
   this.x=x;
   this.y=y;
   c=DividierteDifferenzen();
  }//Ende Konstruktor
//METHODEN:
  double[] DividierteDifferenzen(){
   double[] c=new double[Grad+1];
   for(int i=0;i<=Grad;i++) c[i]=y[i];
   for(int k=1;k<=Grad;k++)
   for(int i=Grad;i>=k;i--) c[i]=(c[i]-c[i-1])/(x[i]-x[i-k]);
   return c;
  }//Ende DividierteDifferenzen()
  double[] Horner(double xi){
   int j;
   double[] b = new double[this.Grad];
   b[Grad-1]=c[Grad];
   for(j=Grad-2;j>=0;j--)  b[j]=c[j+1]+(xi-x[j+1])*b[j+1];
   return b;
  }//ende Horner()
  double getWert(double xi){
   if (Grad==0) return c[0];
   else{
   double[] b=Horner(xi);
   return b[0]*(xi-x[0])+c[0];
   }//Ende else
  }//Ende getWert()
  static void main(String[] args){
   double[] x={1,2,3,4};
   double[] y={1,4,9,16};
   NewtonPolynom p=new NewtonPolynom(3,x,y);
   System.out.println("Wert an der Stelle 1.1: "+p.getWert(1.1));
  }//Ende main()
}//ende class NewtonPolynom

Später kann die Klasse NewtonPolynom als Unterklasse einer abstrakten Klasse Funktion dargestellt, wodurch weitere Methoden, die z.B. den Graphen zeichnet (Polymorphie), eine Wertetabelle erstellt oder die Ableitung an einer Stelle mit Hilfe eines Differenzenquotienten approximiert (Vererbung), zur Verfügung stehen.

Applets

import java.applet.*; //alle Klassen des package java.applet
import java.awt.Graphics; //nur die Klasse Applet des Pakets java.awt
                          //awt= Abstract Window Toolkit
public class Hello extends Applet
{
  public void paint(Graphics g){
  g.drawString("Hello world!",50,25);
}

Die eigene Klasse Tools

 Tools.SetmeinOut("DateiName")