Erklärung:

A x = b , A symmetrisch, Residuum y _i =Ax _i -b Iterationsidee :

• x _{i + 1} = x _i + alpha * p _i
  wobei alpha so beschaffen ist, dass y _{i + 1} * delta x _i = 0
  => alpha -= (delta x _i * (A x _i -b) )/ (delta x _i * A * p _i ).
  => alpha -= (delta x _i * y _i ) / (delta y _i * p _i ).
  ( weil A symmetrisch >> delta x _i * A = delta y _i .
  
• p _i = y _i + beta * delta x _i
  wobei beta so beschaffen ist, dass y _{i + 1} * delta x _{i -1} = 0
  <=> (A ( x _i +alpha * p _i ) -b) ) * delta x _{i - 1} = 0
  Weil y _i * delta x _{i - 1} sowieso 0 ist, gilt
  p _i * A * delta x _{i - 1} = 0 = i * delta y _{i -1}
  => beta -= (y _i * delta y _{i - 1} ) / (delta x _i * delta y _{i - 1} )
  

Die Residuen (y) sind nicht mehr orthogonal wie beim gewöhnlichen cg,
sondern ergeben, ebenso wie die Produkte delta x _i * A * delta x _k , eine Tridiagonal-Matrix.
Pro Iteration sind, wie oben beschrieben, außer der Residuen-Auswertung, pro Iteration 6 n + konst. Multiplikationen zu betätigen.
Als Start-beta wird null genommen . Als Start-x ist ein optimaler Wert ( = lamda ) nicht geeignet,
weil dann die Iteration abbricht.
Es wird daher dieser Wert mit einem Faktor ungleich 1 multipliziert.
Wegen der "Tridiagnonalität" ergibt sich der Zähler von alpha zum (negativen) Nenner des nächsten betas.
=> pro Iteration 5 n + konst. Multiplikationen
Von diesem Zähler < delta x * y (i) > ist der Faktor: delta x = alpha ( i - 1 ) * p ( i - 1 )
Er ergibt sich also zu alpha ( i - 1 ) * y ( i - 1 ) * y( i ),
weil y ( i ) * delta x ( i -1 ) = 0
y ( i - 1 ) * y( i ) ist auch der Zähler von beta , wegen der Tridiagonalität der Residuen.
Der Nenner von alpha (delta y *p) ist komplizierter:
Mit w = y * y und v = y ( i ) * y ( i - 1 ) und az =alpha( i-1 ) * v (Zähler von alpha)
Nenner = delta y * y = w - v + beta( i ) *alpha( i - 1 ) * ( v - w ( i - 1 ) - beta( i - 1 ) * az ( i - 1) )
Wer will, kann nachrechnen, vielleicht geht das auch einfacher!
=> pro Iteration 4n + konst. Multiplikationen, inklusive y * y für die Betragsbestimmung des Residuums.

1. y *y
2. y( i ) * y ( i - 1)
3. Multiplikation mit beta
4. Multiplikation mit alpha

Das Verfahren funktioniert auch nicht, wenn der Startfaktor dem, des normalen cg entspricht:
Da ist alpha0 = - (y0 * y0 ) / ( A p *y0) , y0 = Residum für x = 0 -> y0 = - b.
y( i ) * y ( i - 1) = 0 beim normalen cg.
Das optimale alpha = - (y * Ap ) / ( A p *Ap).
Gute Ergebnisse erhält man für alpha0 nahe dem optimalen Wert (ca 90- 99%).
Weiter kann man Rundungsfehler herabsetzen, wenn man das Residuum nur mir deltaX berechnet.
Dafür muss man den Vektor b jedesmal um delta y verkleinern.
Weil die Matrix A, außer bei der Residuenauswertung, sonst nicht benutzt wird,
ist dieses cg auch für nichtlineare symmetrische Probleme geeignet
(z.B. nichtlineare Ausgleichsrechnung).
Man muss nur beta wieder null setzen, wenn die Rechnung aus dem Ruder läuft.
Für nichtlineare Probleme ist die ursprüngliche Methode mit 6n Multiplikationen pro Iteration vorzuziehen.
Im eindimensionalen Fall, da entsprechen diese Formeln der Sekantenmethode.

Berechnungen:

• y ( i ) * delta y ( i - 1 ) = y ( i ) * y ( i - 1 ), Weil y ( i ) * y ( i - 2 ) = 0
• delta x ( i ) * delta y ( i - 1) = delta x ( i -1 ) *delta y ( i ), Weil A symetrisch
• delta x ( i -1 ) * delta y ( i ) = - delta x ( i -1 ) * y ( i - 1 ), Weil y ( i ) * delta x ( i - 1 ) = 0
• delta x ( i ) * y ( i ) = alpha ( i - 1 ) * p ( i - 1 ) * y ( i ), Weil alpha ( i ) * p( i ) = delta x ( i + 1 )
• p ( i - 1 ) * y( i ) = y( i - 1) * y ( i ) , Weil y ( i ) * delta x ( i - 1 ) = 0
• delta y ( i) * p ( i ) = delta y ( i ) * y ( i ) + beta ( i ) * delta y ( i ) * delta x ( i )
• delta y ( i ) * delta x ( i ) = alpha ( i - 1 ) *delta y ( i ) * p ( i - 1 ), Weil alpha ( i ) * p( i ) = delta x ( i + 1 )
• delta y ( i ) * p ( i - 1 ) = y ( i ) * y ( i - 1 ) - y ( i - 1 ) * p ( i - 1 )
• y ( i - 1 ) * p ( i - 1 ) = y ( i - 1 ) * y ( i - 1 ) + beta ( i - 1 ) * y ( i - 1 ) * delta x ( i -1 )
• y ( i - 1 ) * delta x ( i -1 ): Zähler von alpha ( i - 1 )