NumAnalysis
NumAnalysis mit einigen Methoden der Interpolation (und
später der numerischen Integration) zu bestücken, so dass die
folgende Applikationsklasse lauffähig wird:
public class BspNumAn{
static void main(String[] args){
double[] x={0.1,0.2,0.3,0.4};
double[] y={0.01,0.03,0.07,0.1};
Funktion p1=NumAnalysis.PolynomInterpolation(x,y);
Wurzel w =new Wurzel(0,1);
Funktion p2= NumAnalysis.PolynomInterpolation(w,10);
Funktion p3 =NumAnalysis.PolynomInterpolation(w,10,'t');
}//Ende main()
}//Ende Applikationsklasse BspNumAn
NumAnalysis drei
verschiedene Methoden mit dem Namen
PolynomInterpolation() und dem Rückgabewert
Funktion, aber mit unterschiedlichen Parametern,
man spricht von Überladen von
Methoden. In allen drei Fällen wird die
InterpolationsFunktion der Klasse
Interpolation zurückgegeben, im ersten Fall werden
Interpolationspunkte interpoliert, in den beiden anderen Fällen
wird die Wurzelfunktion auf dem Intervall [0,1] an 11 Knoten
interpoliert, zunächst an äquidistanten, dann an
T-Knoten. Die Methoden werden so implementiert, dass die
Interpolationen in dem Sinne der Projektaufgabe1 visualisiert werden.
Dass die Methode PolynomInterpolation() ohne
Instanziierung eines Objekts der Klasse NumAnalysis nur
durch Vorschalten des Namens dieser Klasse aufgerufen werden, liegt
daran, dass diese Methoden den Zusatz static erhalten. Ihre Verwendung ist analog zu
der der Methoden der Klasse Math.
public class NumAnalysis{
public static Funktion PolynomInterpolation(double[] x, double[] y){
NewtonInterpolation NIP = new NewtonInterpolation(x,y);
NIP.InterpolationsFunktion.setIntervall(x[0],x[x.length-1]);
//unterstellt, dass x[0]<x[1]<...<x[n]
NIP.Zeichne();
return NIP.InterpolationsFunktion;
}//Ende PolynomInterpolation 1
public static Funktion PolynomInterpolation(Funktion f,int N){
double[] x = new double[N+1];
for (int i=0;i<=N;i++) x[i]=f.xMin+i*(f.xMax-f.xMin)/N;
NewtonInterpolation NIP=new NewtonInterpolation(x,f);
NIP.IP.setName("aequidistante Knoten");
NIP.Zeichne();
return NIP.InterpolationsFunktion;
}//Ende PolynomInterpolation 2
public static Funktion PolynomInterpolation(Funktion f,int N,char T){
double[] x = new double[N+1];
for (int i=0;i<=N;i++)
x[i]=0.5*(f.xMin+f.xMax+(f.xMax-f.xMin)*Math.cos((2.0*i+1)/(2.0*N+2)*Math.PI));
NewtonInterpolation NIP=new NewtonInterpolation(x,f);
NIP.IP.setName("T-Knoten");
NIP.Zeichne();
return NIP.InterpolationsFunktion;
}//Ende PolynomInterpolation 3
}//Ende class NumAnalysis
Interpolation, wie
in der Projektaufgabe gefordert, eine starke Methode
Zeichne() zugefügt wurde.
Generell können auch Klassen, von denen Objekte instanziiert
werden sollen, Methoden und Daten haben, die den Modifier
static tragen. Solche Methoden heißen
Klassenmethoden und solche Daten Klassenvariable. Sie
sind unabhängig von den individuellen Objekten dieser
Klasse. Wollen Sie ein Beispiel? Wir könnten der Klasse
Funktion das Attribut public static String
AutorIn="Jolanta" und die Methode
public static void getAutorin(){
System.out.println(AutorIn);
}
NumIntegration
SimpsonAd, die ein adaptives
Simpsonverfahren implementiert.
public class NumIntegration{
public static double Simpson(Funktion f, double a, double b){
double s=(b-a)/6*(f.getY(a)+4*f.getY((a+b)/2)+f.getY(b));
return s;
}//Ende Simpson()
public static double SimpsonAd(Funktion f, double a, double b, double delta){
double c=(a+b)/2;
double h=b-a;
double fa=f.getY(a);
double fc=f.getY(c);
double fb=f.getY(b);
double S_ab=(b-a)/6*(fa+4*fc+fb);
double S_ac=(c-a)/6*(fa+4*f.getY((a+c)/2)+fc);
double S_cb=(b-c)/6*(fc+4*f.getY((c+b)/2)+fb);
double S=S_ac+S_cb; //Schaetzer
double Q=S_ab; //Simpsons Quadraturformel
if (Math.abs(Q-P)>h*delta) {
double Ad_ac=SimpsonAd(f,a,c,delta);
double Ad_cb=SimpsonAd(f,c,b,delta);
return Ad_ac+Ad_cb;
}
else{
return Q; //besser: Q+(Q-P)/15;
}
}//Ende SimpsonAd
}//Ende class NumIntegration