Die Mathe-Redaktion - 19.10.2019 04:39 - Registrieren/Login
Auswahl
ListenpunktHome
ListenpunktAktuell und Interessant ai
ListenpunktArtikelübersicht/-suche
ListenpunktAlle Links / Mathe-Links
ListenpunktFach- & Sachbücher
ListenpunktMitglieder / Karte / Top 15
ListenpunktRegistrieren/Login
ListenpunktArbeitsgruppen
Listenpunkt? im neuen Schwätz
ListenpunktWerde Mathe-Millionär!
ListenpunktFormeleditor fedgeo
Schwarzes Brett
Aktion im Forum
Suche
Stichwortsuche in Artikeln und Links von Matheplanet
Suchen im Forum
Suchtipps

Bücher
Englische Bücher
Software
Suchbegriffe:
Mathematik bei amazon
Naturwissenschaft & Technik
In Partnerschaft mit Amazon.de
Kontakt
Mail an Matroid
[Keine Übungsaufgaben!]
Impressum

Bitte beachten Sie unsere Nutzungsbedingungen, die Distanzierung, unsere Datenschutzerklärung und
die Forumregeln.

Sie können Mitglied werden. Mitglieder können den Matheplanet-Newsletter bestellen, der etwa alle 2 Monate erscheint.

Der Newsletter Okt. 2017

Für Mitglieder
Mathematisch für Anfänger
Wer ist Online
Aktuell sind 144 Gäste und 3 Mitglieder online.

Sie können Mitglied werden:
Klick hier.

Über Matheplanet
 
Zum letzten Themenfilter: Themenfilter:
Matroids Matheplanet Forum Index
Moderiert von matroid
Mathematik » Numerik & Optimierung » Newtonverfahren
Druckversion
Druckversion
Antworten
Antworten
Autor
Universität/Hochschule Newtonverfahren
Aliaju
Junior Letzter Besuch: im letzten Monat
Dabei seit: 25.04.2019
Mitteilungen: 13
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Themenstart: 2019-09-19


Hallo,

ich hatte schon mal einen ähnlichen Beitrag. Da ging es aber um das Gradientenverfahren.

Es geht darum mit Backtracking (Pseudo-Code und Implementierung sind unten) diesmal mit dem Newtonverfahren das Minimum der Rosenbrock Funktion $f(x)=100(x_2-x_1^2)^2+(1-x_1)^2$ zu finden.



Ich lande leider in einer Endlosschleife und zwar im main-Thread, den ich hier einbinde:

(fx() gibt den Funktionswert aus. Das funktioniert. Das habe ich getestet. pnewton() ist die Methode, die die Richtung $p_k$ entsprechend der Newton-Methode ausgibt. Das sind alles Vektoren, die ich in einem Array gespeichert habe, wobei die erste Koordinate immer an der 0-ten und die zweite an der 1-ten Stelle des Array stehen.)
Java
public static void main(String[] args){
 
                double [] x = {1.2,1.2};
                int i=0;
		double alphan=1;
 
		while(fx(x)>0.00000001 & norm(x)>0.00000001) {
 
			alphan=alphan(alphan,0.5,0.0001,x);
 
			x[0]+=alphan*pnewton(x)[0];
			x[1]+=alphan*pnewton(x)[1];
 
		}
 
	}


Das Problem ist, dass nach dem Ausführen der Methode alphan() das neue alphan so klein ist, dass es gar keine Veränderungen mehr an $x$ vornimmt. Der alphan-Wert ist irgendwas mit E-16 am Ende. (Und wähle ich $x[0]=1.2$ bleibt der Wert beibehalten. Das passiert für alle $x\neq 0$.)

Und aus diesem Grund wird die while-Bedingung in der Methode alphan() nicht mehr erfüllt. Ich gebe erstmal den Pseudo-Code an und dann meine Implementierung.

Der Pseudo-Code:


Meine Implementierung:
Java
	public static double alphan(double alpha, double rho, double c, double[] x) {
		double[] xap=new double[2];
		xap[0]=x[0]+alpha*pnewton(x)[0];
		xap[1]=x[1]+alpha*pnewton(x)[1];
		double wert = fx(x)+alpha*c*((grad(x)[0]*pnewton(x)[0])+(grad(x)[1]*pnewton(x)[1]));
 
		while(fx(xap)>(wert)){
 
			alpha=rho*alpha;
 
 
			wert=fx(x)+alpha*c*((grad(x)[0]*pnewton(x)[0])+(grad(x)[1]*pnewton(x)[1]));
			xap[0]=x[0]+alpha*pnewton(x)[0];
			xap[1]=x[1]+alpha*pnewton(x)[1];	
		}	
		return alpha;
	}

Das Problem ist, dass sich dadurch, dass das $x$ nicht mehr verändert wird "fx(xap)" und "wert" nicht mehr verändern. Dadurch wird $fx(xap)>(wert)$ nie erfüllt, da die Werte gleich bleiben.

Das Problem entsteht wohl einfach dadurch, dass das "alpha" überhaupt so klein wird. Es sollte nicht so klein werden :/ und ich weiß einfach echt nicht, warum das so ist.
Ich hatte das gleiche Problem schon mal als es ums Gradientenverfahren ging. Da hatte ich vergessen die Variable "c" mitzumultiplizieren. Aber das habe ich ja hier gemacht....

Ich habe das Gradientenverfahren mit dem analogen Code programmiert. (Unterscheidet sich nur in der Variable "pnewton".) Und da funktioniert das Programm!! Und endet. $x$ konvergiert gegen $(1.0,1.0)$.

Auch wenn ich es gründlich berechnet habe, schreibe ich hier noch auf, wie ich die Methode pnewton() gewählt habe. Dadurch, dass der Code ja für das Gradientenverfahren funktioniert, kann es ja nicht an den anderen Methoden liegen. Die kann ich aber sehr gerne auch noch posten, wenn ihr sie sehen wollt.

Also unser $p_k$ soll in der Newtonmethode gewählt werden durch:


Dafür mussten viele Rechnungen vorgenommen werden, die ich euch jetzt zeige.

Für die ersten Ableitungen gilt
$\frac{\partial f}{\partial x_1}=2(200x_1^3-200x_1x_2+x_1-1)$
und
$\frac{\partial f}{\partial x_2}=200(x_2-x_1^2)$
Für die zweiten Ableitungen gilt
$\frac{{\partial}^{2}f}{\partial x_1^2}=1200x_1^2-400x_2+2$
$\frac{{\partial}^{2}f}{\partial x_1 \partial x_2}=-400x_1$
$\frac{{\partial}^{2}f}{\partial x_2 \partial x_1}=-400x_1$
$\frac{{\partial}^{2}f}{\partial x_2^2}=200$

Deswegen erhalten wir für die Hesse-Matrix
fed-Code einblenden

und nach der Formel der Inversen


ergibt sich für die Inverse
fed-Code einblenden

um das $p_k$ zu bestimmen fehlt also nur noch die Multiplikation mit dem Gradienten und das negative Vorzeichen.

Also, Multiplikation mit dem Gradienten:

fed-Code einblenden

Wenn wir jetzt noch das Vorzeichen davorsetzen haben wir also unser $p_k$. Das ist dann gegeben durch:

\[ \begin{pmatrix} -\frac{x_1 -1}{200 x_1^2 -200x_2+1} \\ -\left(\frac{2(x_1 -1)x_1}{200x_1^2 -200 x_2 +1}\right) +x_1^2 -x_2 \end{pmatrix}, \]

Und genau das habe ich auch in meinen Code geschrieben:
Java
public static double[] pnewton(double[] x) {		
		double[] pn = {
                -(x[0]-1)/(200*Math.pow(x[0],2)-200*x[1]+1),
                -(2*(x[0]-1)*x[0])/(200*Math.pow(x[1],2)-200*x[1]+1)+Math.pow(x[0],2)-x[1]
                 };
		return pn;
	}
}

Erkennt ihr einen Fehler?
Ansonsten ist mein Code nämlich exakt so, wie der mit dem alpha fürs Gradientenverfahren, der funktioniert. Falls ihr den sehen möchtet, ist er hier:
Java
	public static double alpha(double alpha, double rho, double c, double[] x) {
		double[] xap=new double[2];
		xap[0]=x[0]+alpha*psd(x)[0];
		xap[1]=x[ 1]+alpha*psd(x)[1];
		double wert = fx(x)+alpha*c*((grad(x)[0]*psd(x)[0])+(grad(x)[1]*psd(x)[1]));
 
		while(fx(xap)>(wert)){
			alpha=rho*alpha;
 
			wert=fx(x)+alpha*c*((grad(x)[0]*psd(x)[0])+(grad(x)[1]*psd(x)[1]));
			xap[0]=x[0]+alpha*psd(x)[0];
			xap[1]=x[1]+alpha*psd(x)[1];
 
		}		
		return alpha;
	}


Habt ihr eine Idee, woran es liegen kann?
Seht ihr einen Fehler?












  Profil  Quote  Link auf diesen Beitrag Link
Monom
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 29.05.2015
Mitteilungen: 92
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.1, eingetragen 2019-09-19


Hallo Aliaju,

ich habe deine Formeln nicht nachgerechnet. Wenn aber dieses Ergebnis hier stimmt
\[ \begin{pmatrix} -\frac{x_1 -1}{200 x_1^2 -200x_2+1} \\ -\left(\frac{2(x_1 -1)x_1}{200x_1^2} -200 x_2 +1\right) -x_1^2 +x_2 \end{pmatrix}, \] dann hast Du die zweite Komponente in pnewton() nicht korrekt geklammert:
Java
public static double[] pnewton(double[] x) {
 
		double[] pn = {
			-(x[0]-1)/(200*Math.pow(x[0],2)-200*x[1]+1),
			-(2*(x[0]-1)*x[0]/(200*Math.pow(x[1],2))-200*x[1]+1)-Math.pow(x[0],2)+x[1]
		};
		return pn;
}

Viele Grüße
Monom



  Profil  Quote  Link auf diesen Beitrag Link
Aliaju
Junior Letzter Besuch: im letzten Monat
Dabei seit: 25.04.2019
Mitteilungen: 13
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.2, vom Themenstarter, eingetragen 2019-09-19


Hallo Monom,

danke für deine Antwort.
Leider war das nur hier in meinem Beitrag falsch geschrieben und nicht in meinem Code. (Jetzt aber im Ursprungsthread korrigiert.)
Habe dabei aber auch bemerkt, dass ich beim Vorzeichen setzen dort in der zweiten Komponente einen kleinen Fehler gemacht habe, was die letzten beiden Terme betrifft. Aber das hat leider auch keinen Unterschied gemacht...

Also, Korrektur:

Für unser $p_k$ gilt
\[ \begin{pmatrix} -\frac{x_1 -1}{200 x_1^2 -200x_2+1} \\ -\left(\frac{2(x_1 -1)x_1}{200x_1^2 -200 x_2 +1}\right) +x_1^2 -x_2 \end{pmatrix}, \]
und für unsere Methode pnewton(), in der wir $p_k$ bestimmen gilt
Java
public static double[] pnewton(double[] x) {		
		double[] pn = {
                -(x[0]-1)/(200*Math.pow(x[0],2)-200*x[1]+1),
                -(2*(x[0]-1)*x[0])/(200*Math.pow(x[1],2)-200*x[1]+1)+Math.pow(x[0],2)-x[1]
                 };
		return pn;
	}
}


Hoffe, es findet sich noch jemand der meinen Fehler entdeckt...



  Profil  Quote  Link auf diesen Beitrag Link
gonz
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 16.02.2013
Mitteilungen: 3202
Aus: Harz
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.3, eingetragen 2019-09-19


Muss es denn einen Fehler geben?

Oder kann es eben auch daran liegen, dass die Rosenbrock Funktion so gebaut ist, dass Näherungsverfahren ggf. nicht funktionieren, genau aufgrund solcher Effekte wie du sie beschrieben hast, dass die Schrittweite einen Wert unterhalb der Maschinengenauigkeit annimmt?


-----------------
~ to fight! (Don Quijote de la Mancha)



  Profil  Quote  Link auf diesen Beitrag Link
Aliaju
Junior Letzter Besuch: im letzten Monat
Dabei seit: 25.04.2019
Mitteilungen: 13
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.4, vom Themenstarter, eingetragen 2019-09-19


Ja, muss es.

Die Werte sind extra $\rho=\frac{1}{2}$,$c=10^{-4}$, $\alpha=1$ und Startwert $x=[1.2,1.2]^T$.

Es sollte (ziemlich sicher) gegen den Wert x=[1.0,1.0] konvergieren. Das passiert auch bei meinem Programm mit dem Gradientenverfahren.
Und wenn ich die Vorgaben verwende, muss es auf jeden Fall enden und nicht in einer Endlosschleife landen.



  Profil  Quote  Link auf diesen Beitrag Link
Kitaktus
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 11.09.2008
Mitteilungen: 6049
Aus: Niedersachsen
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.5, eingetragen 2019-09-19


Kannst Du mal ein paar Werte aufschreiben. Was ist x, wie sieht die Newton-Richtung aus, wie die Schrittweite usw.

Beim Newtonverfahren ist es prinzpiell möglich, dass man in einer Schleife festhängt (wenn mich meine Erinnerung nicht zu sehr trügt).



  Profil  Quote  Link auf diesen Beitrag Link
Aliaju
Junior Letzter Besuch: im letzten Monat
Dabei seit: 25.04.2019
Mitteilungen: 13
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.6, vom Themenstarter, eingetragen 2019-09-19


Ja, gerne!

Also, in der Schleife meiner alphan()-Methode gilt für die ersten vier Ausführungen:

alpha: 0.5
xap (erste Komponente): 1.1286542409056957
xap (zweite Komponente): 1.42633261520313
fx(xap): 2.341329691383484
wert: 0.04749227981844722
pnewton (erste Komponente): -0.06726412644124304
pnewton (zweite Komponente): 0.005675236049886179


alpha: 0.25
xap (erste Komponente): 1.1622863041263172
xap (zweite Komponente): 1.423494997178187
fx(xap): 0.553202970361043
wert: 0.04751103807391423
pnewton (erste Komponente): -0.06726412644124304
pnewton (zweite Komponente): 0.005675236049886179

alpha: 0.125
xap (erste Komponente): 1.179102335736628
xap (zweite Komponente): 1.4220761881657153
fx(xap): 0.13316266379024802
wert: 0.047520417201647736
pnewton (erste Komponente): -0.06726412644124304
pnewton (zweite Komponente): 0.005675236049886179

alpha: 0.0625
xap (erste Komponente): 1.1875103515417833
xap (zweite Komponente): 1.4213667836594794
fx(xap): 0.04767267663431407
wert: 0.04752510676551449
pnewton (erste Komponente): -0.06726412644124304
pnewton (zweite Komponente): 0.005675236049886179

Ich glaube "Schrittweite" bezieht sich ja auf das alpha. (Nach der Aufgabe soll mit alpha=1.0 angefangen werden. Ich hab die Werte hier nach "alpha=rho*alpha" ausgeben lassen.)
Meine Variable "fx(xap)" ist der Funktionswert von $xap=x_k +\alpha p_k$.
Meine Variable "wert" ist die rechte Seite in der while-Bedingung, also: $f(x_k)+ \alpha c p_k^T grad(f(x_k))$.
Und die Newtonrichtung ist gegeben durch die beiden Komponenten in pnewton...



Jetzt die Werte, die ich in der main-Methode ausgegeben bekomme nach dem i-ten Ausführen von alphan():

Nach 1-tem Ausführen der alphan()-Methode:
x[0]: 1.1959183673469387
x[1]: 1.4206573791532437
alpha: 1.0
pnewton (erste Komponente): -0.06726412644124304
pnewton (zweite Komponente): 0.005675236049886179

Nach 2-tem Ausführen der alphan()-Methode:
x[0]: 1.1917143594443609
x[1]: 1.4203907800953284
alpha: 0.0625
pnewton (erste Komponente): -0.2000218922766692
pnewton (zweite Komponente): -0.00400207639020933

Nach 3-tem Ausführen der alphan()-Methode:
x[0]: 1.191323691686008
x[1]: 1.420381162753379
alpha: 0.001953125
pnewton (erste Komponente): -0.2471259322158494
pnewton (zweite Komponente): -0.004914573037810843

Nach 4-tem Ausführen der alphan()-Methode:
x[0]: 1.191323691686008
x[1]: 1.420381162753379
alpha: 4.440892098500626E-16
pnewton (erste Komponente): -0.2471259322158494
pnewton (zweite Komponente): -0.004914573037810843

Nach 5-tem Ausführen der alphan()-Methode:
x[0]: 1.191323691686008
x[1]: 1.420381162753379
alpha: 4.440892098500626E-16
pnewton (erste Komponente): -0.2471259322158494
pnewton (zweite Komponente): -0.004914573037810843

Und nach dem 4.Mal findet dann leider keine Veränderung mehr statt, weil wahrscheinlich alpha zu klein ist...


Falls die auch noch interessant sind, habe ich mir noch die Werte in der Methode alphan() ausgeben lassen, sobald das Programm aus der while-Schleife rausgeht.
Das sind:

x[0]: 1.2
x[1]: 1.2
alpha: 1.0
xap (erste Komponente): 1.1959183673469387
xap (zweite Komponente): 1.4302040816326531
fx(xap): 0.0383840344185341
wert: 5.798847836734693

x[0]: 1.1959183673469387
x[1]: 1.4206573791532437
alpha: 0.0625
xap (erste Komponente): 1.1917143594443609
xap (zweite Komponente): 1.4210120814063616
fx(xap): 0.03682311422937044
wert: 0.04752745154744787

x[0]: 1.1917143594443609
x[1]: 1.4203907800953284
alpha: 0.001953125
xap (erste Komponente): 1.191323691686008
xap (zweite Komponente): 1.4203829635398788
fx(xap): 0.036732631556307856
wert: 0.03675867910504426

x[0]: 1.191323691686008
x[1]: 1.420381162753379
alpha: 4.440892098500626E-16
xap (erste Komponente): 1.191323691686008
xap (zweite Komponente): 1.420381162753379
fx(xap): 0.036732224605651974
wert: 0.036732224605651974







  Profil  Quote  Link auf diesen Beitrag Link
Aliaju
Junior Letzter Besuch: im letzten Monat
Dabei seit: 25.04.2019
Mitteilungen: 13
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.7, vom Themenstarter, eingetragen 2019-09-19


Also,

das ist der gesamte Code für das Newtonverfahren.
Java
public class Newton {
 
	public static double fx(double[] x) {
		return 100*Math.pow((x[1]-Math.pow(x[0], 2)),2)+Math.pow((1-x[0]),2);
	}
 
	public static double[] grad(double[] x) {
		double grad[] = new double[2];
		grad[0]=2*(200*Math.pow(x[0],3)-200*x[0]*x[1]+x[1]-1);
		grad[1]=200*(x[1]-Math.pow(x[0],2));
		return grad;
	}
	public static double[] psd(double[] x) {	
		double[] psd = new double[2];
		psd[0]=-(x[0]-1)/(200*Math.pow(x[0],2)-200*x[1]+1);
		psd[1]=-(2*(x[0]-1)*x[0])/(200*Math.pow(x[0],2)-200*x[1]+1)+Math.pow(x[0],2)-x[1];
		return psd;
	}
 
	public static double alpha(double alpha, double rho, double c, double[] x) {
 
		double[] xap=new double[2];
		xap[0]=x[0]+alpha*psd(x)[0];
		xap[1]=x[ 1]+alpha*psd(x)[1];
		double wert = fx(x)+alpha*c*((grad(x)[0]*psd(x)[0])+(grad(x)[1]*psd(x)[1]));
 
		while(fx(xap)>(wert)){
			alpha=rho*alpha;
 
 
			wert=fx(x)+alpha*c*((grad(x)[0]*psd(x)[0])+(grad(x)[1]*psd(x)[1]));
			xap[0]=x[0]+alpha*psd(x)[0];
			xap[1]=x[1]+alpha*psd(x)[1];
 
 
		}
 
 
		return alpha;
	}
 
	public static void main(String[] args) {
		double [] x = {1.2,1.2};
 
		double alpha=1;
		while(fx(x)>0.00000001 & norm(x)>0.00000001) {
 
			alpha=alpha(alpha,0.5,0.0001,x);
			x[0]+=alpha*psd(x)[0];
			x[1]+=alpha*psd(x)[1];
 
		}
		System.out.println("x0 = "+x[0]);
		System.out.println("x1 = "+x[1]);
 
	}
 
	public static double norm(double[] x) {
		double k = (Math.sqrt(2*Math.pow((200*Math.pow(x[0],3)-200*x[0]*x[1]+x[0]-1),2)+40000*Math.pow(x[1]-Math.pow(x[0],2),2))) ;
		return k;
	}
 
}
 

Ersetze ich die psd()-Methode mit der psd()-Methode des Gradientenverfahrens funktionierts:
Java
public static double [] psd(double[] x) {
		double psd[] = new double[2];
		psd[0]=-(2*(200*Math.pow(x[0],3)-200*x[0]*x[1]+x[0]-1)/(Math.sqrt(2*Math.pow((200*Math.pow(x[0],3)-200*x[0]*x[1]+x[0]-1),2)+40000*Math.pow(x[1]-Math.pow(x[0],2),2))));
		psd[1]=-((200*(x[1]-Math.pow(x[0],2)))/(Math.sqrt(2*Math.pow((200*Math.pow(x[0],3)-200*x[0]*x[1]+x[0]-1),2)+40000*Math.pow(x[1]-Math.pow(x[0],2),2))) );
		return psd;
	}




  Profil  Quote  Link auf diesen Beitrag Link
Delastelle
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 17.11.2006
Mitteilungen: 1348
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.8, eingetragen 2019-09-20


Hallo Aliaju!

Funktioniert das Verfahren wenn Du in der Nähe des Optimums startest?

Viele Grüße
Ronald



  Profil  Quote  Link auf diesen Beitrag Link
Aliaju
Junior Letzter Besuch: im letzten Monat
Dabei seit: 25.04.2019
Mitteilungen: 13
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.9, vom Themenstarter, eingetragen 2019-09-20


Hallo Ronald,

mit x=[1.2,1.2] starte ich doch ziemlich nah am Infimum... Da konvergierts nicht. Es ist am Ende x=[1.13...,1.28...].

Aber mit x=[-1.2,1.0] konvergierts... Finde das ziemlich seltsam. Bei allen anderen bei denen ich den Code gesehen habe, konvergierts am Ende...



  Profil  Quote  Link auf diesen Beitrag Link
majoka
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 25.02.2014
Mitteilungen: 774
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.10, eingetragen 2019-09-20


Bei geht es, wenn ich Deinem Code den Initialwert
Java
double alpha=.1;

in der Main setze.



  Profil  Quote  Link auf diesen Beitrag Link
Aliaju
Junior Letzter Besuch: im letzten Monat
Dabei seit: 25.04.2019
Mitteilungen: 13
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.11, vom Themenstarter, eingetragen 2019-09-23 20:18


Hallo Majoka, danke für deine Antwort. ".1" bedeutet 0.1...?



  Profil  Quote  Link auf diesen Beitrag Link
majoka
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 25.02.2014
Mitteilungen: 774
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.12, eingetragen 2019-09-23 21:14


Ja, sollte beides gleichwertig sein.



  Profil  Quote  Link auf diesen Beitrag Link
Aliaju
Junior Letzter Besuch: im letzten Monat
Dabei seit: 25.04.2019
Mitteilungen: 13
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.13, vom Themenstarter, eingetragen 2019-09-24 02:41


Ah okay. Aber was sagt mir das denn jetzt? Alpha soll ja 1 sein... Ich hatte ja auch Werte, wie der Algorithmus am Ende konvergiert...



  Profil  Quote  Link auf diesen Beitrag Link
Aliaju hat die Antworten auf ihre/seine Frage gesehen.
Neues Thema [Neues Thema] Antworten [Antworten]    Druckversion [Druckversion]

 


Wechsel in ein anderes Forum:
 Suchen    
 
All logos and trademarks in this site are property of their respective owner. The comments are property of their posters, all the rest © 2001-2019 by Matroids Matheplanet
This web site was made with PHP-Nuke, a web portal system written in PHP. PHP-Nuke is Free Software released under the GNU/GPL license.
Ich distanziere mich von rechtswidrigen oder anstößigen Inhalten, die sich trotz aufmerksamer Prüfung hinter hier verwendeten Links verbergen mögen.
Lesen Sie die Nutzungsbedingungen, die Distanzierung, die Datenschutzerklärung und das Impressum.
[Seitenanfang]