Link zum FSI-Thread:
[[https://fsi.informatik.uni-erlangen.de/forum/thread/7529-Klausur-vom-Februar-2010-Loesungsversuch]]
==== Aufgabe 1 - Komplexität ====
* O(n³)
* O(n)
* O(n²)
* O(n³)
* O(n²)
* O(n²)
* O(n)
* O(n³)
==== Aufgabe 2 - Multiple Choice ====
* j= Ja
* n = Nein
**a)**
n n j n j
**b)**
n n n j n
**c)**
n n n n j
**d)**
j j n j j
==== Aufgabe 3 - Dünnbesetzte Matrizen ====
**a)**
0 0 1 0 3
4 0 0 2 1
0 0 0 0 0
1 3 2 0 0
**b)**
* Werte: 3 -1 2 4 -5
* Zeile: 1 2 3 1 3
* ColPtr: 1 2 2 4 6
==== Aufgabe 4 - Lineares Ausgleichsproblem ====
**a)**
A^T * A * x = A^T * b
**b)**
* m = 5/14
* t = 3/14
==== Aufgabe 5 - 2D Interpolation ====
**a)**
* P1 = (9,12)^T
* P2 = (10,0)^T
**b)**
* h1 = rho1*hR + sigma1*hS + tau1*hT = 120
* h2 = rho2*hR + sigma2*hS + tau2*hT = 80
**c)**
ρ = 1/3 \\
σ= 1/3 \\
τ= 1/3
**d)**
Punkt P teilt Dreieck in drei Teil-Dreiecke. Das Verhältnis jedes Teil-Dreiecks (Punkt P und je zwei der anderen ursprünglichen Punkte) zum ganzen Dreieck ergibt jeweils eine baryzentrische Koordinate.
**e)**
Bild 1: Gerade durch T und die Mittelsenkrechte der Strecke RS \\
Bild 2: Gerade durch T und S
**f)**
f(P4) = 39
f(P5) = 57
==== Aufgabe 6 - Coons-Patches====
s
F(s,t) = t
s^2*t + s*t^2 - s*t
==== 7. Filtern ====
**a)**
* F1: 1/2 (1, 0, 1)^T und 1/2 (1, 0, 1)
* F2: geht nicht
* F3: 1/4 (1, 1, 1)^T und 1/3 (1, 1, 1, 1)
**b)**
Geringerer Aufwand
**c)**
x x x x x
x 0 5 2 x
x 0 4 2 x
x 0 5 2 x
x x x x x
==== Aufgabe 8 - Iterative Lösungsverfahren ====
**a)**
* x1 = 4
* x2 = -5
* x3 = 2
**b)**
* x1 = 4
* x2 = -5
* x3 = 9/4
**c)**
Für dünnbesetzte Matrizen besonders gut geeignet.
==== Aufgabe 9 - LR- Zerlegung ====
**a)**
1 0 0 0 2 -1 0 0
2 1 0 0 0 2 1 0
0 -2 1 0 0 0 1 1
0 0 -2 1 0 0 0 -1
L R
**b)**
x = (3/2, 1, -4, 2)^T
==== Aufgabe 10 - Aitken-Neville ====
**a)**
NewtonPolynom :: NewtonPolynom(const float *_x, const float *_y, const int _n)
{
n = _n;
x = new float[n];
y = new float[n];
a = new float[n];
for (int i = 0; i < n; i++) {
x[i] = _x[i] ;
y[i] = _y[i] ;
}
// Erster Koeffizient
a[0] = y[0];
for (int row = 1; row < n; row++)
{
for (int col = 0; col < n-col; col++)
{
y[col] = (y[col+1] - y[col]) / (x[row+col] - x[col]);
}
// Übernehme Koeffizienten (der immer im höchsten Element ist)
a[row] = y[0];
}
}
**b)**
float NewtonPolynom::operator()(const float x0) const
{
float result = a[n-1];
for (int i = n-2; i >= 0; i--)
{
result = a[i] * (x0 - x[i]) + result;
}
return result;
}