Tiefster Wert der Gammafunktion

Hallo
Im Netz finde ich irgendwie gar nichts davon.
Es geht darum, den tiefsten Wert der Gammafunktion zu ermitteln und bei welchem x er auftaucht, also einen Wert zwischen 1 und 2. Eigentlich müsste dieser ja irgendwo definiert sein, oder sehe ich das falsch? Zumindest habe ich schon mal herausfinden können, dass er nicht bei 1,5 zu finden ist, sondern irgendwo zwischen 1,449 und 1,45. Aber ist mein Verfahren auch grundsätzlich richtig?

	private static final double C0 = 1.0;
	private static final double C1 = 1.0 / 12.0;
	private static final double C2 = 1.0 / 288.0;
	private static final double C3 = -139.0 / 51840.0;
	private static final double C4 = -571.0 / 2488320.0;
	private static final double C5 = 163879.0 / 209018880.0;
	private static final double C6 = 5246819.0 / 75246796800.0;
	private static final double C7 = -534703531.0 / 902961561600.0;
	private static final double C8 = -4483131259.0 / 86684309913600.0;
	private static final double C9 = 432261921612371.0 / 514904800886784000.0;

	public static void main(String[] args) {
		double a = 1.0;
		double b = 2.0;
		double c = 0.0;
		double g = 1.0;
		double d = 1.0;
		double v = 0.0;
		while(b != a) {
			c = (a + b) / 2.0;
			g = gamma(c);
			if(d > g) {
				d = g;
				if (b == 2.0) {
					b = c;
				} else {
					b = (c + b) / 2.0;
				}
				v = c;
			} else {
				a = c;
			}
		}
		System.out.println(v);
		System.out.println(d);
	}

	private static double gamma(double value) {
		if(value < 0) {
			throw new IllegalArgumentException("only positive values and 0 allowed");
		}
		if(value == 0.0) {
			return POSITIVE_INFINITY;
		}
		boolean integer = value == floor(value);
		double offset = 1;
		value -= 1;
		while (value <= 15) {
			value += 1;
			offset *= value;
		}
		double z = 1 / value;
		z = sqrt(2 * PI * value)
				* pow(value / E, value)
				* (((((((((C9 * z + C8) * z + C7) * z + C6) * z + C5) * z + C4)
				* z + C3)
				* z + C2)
				* z + C1)
				* z + C0) / offset;
		return (integer && !Double.isInfinite(z)) ? floor(z) : z;
	}
}```Ausgabe:

1.4499999999999507
0.8856613802710709


Darüber hinaus würde mich noch interessieren, wie man an die gegenüberliegenden X-Werte kommt, also jene, die den selben Y-Wert haben. Geht sowas?

Da würde ich nicht mit Java rangehen, sondern ein CAS verwenden (z. B. Mathematica oder einen Grafiktaschenrechner).
Du musst die erste Ableitung = 0 setzen, ggf. Definitionsbereich von x auf > 0 setzen:
[tex]0=\frac{\mathrm{d}}{\mathrm{d}x}\int\limits_0^\infty t^{x-1}e^{-t}\mathrm{d}t[/tex]
Alternativ haben Mathematikprogramme die Gammafunktion teilweise auch integriert, damit sollte sich die Extremstelle dann auch problemlos ausgeben lassen.

Ja, das geht. Grundsätzlich müsstest du die Funktion umstellen und nach x auflösen. Das wird bei der Gammafunktion nicht gelingen, weshalb das Problem auch nur numerisch für gewählte Werte gelöst werden kann.

Wolfram gibt 1.46163… an, Sloane dann 1.461632144968362341262659542325721328468196204006446351295988409

Ok, danke für die Antworten.
@cmrudolph :

  1. Tja… das ist das Problem. Ich wollte eine Lösung in Java.
  2. Eben… die Gammafunktion ist nicht reversibel. Deswegen hatte ich gehofft, dass es etwas gibt, wo man den tiefsten Punkt ermittelt und die beiden Strecken rechts und links davon in ein Verhältnis setzen kann.
    @Landei : 1,46…? Also die Begrenzung zwischen 1,449 und 1,45 ist lt. Taschenrechner (Windowsrechner über n! und Casio FX-sonstwas) schon korrekt. Wie kommen die denn da auf andere Werte? Liegt das etwa an der Berechnung der Funktion selber?

Keine Ahnung, es wird nur überall im Netz dieser Wert angegeben.

Der Wert von 1,46… sollte schon stimmen, da rechnt dein Taschenrechner wohl zu ungenau.
http://www.mathe-online.at/Mathematica/
Gib da einfach mal in den Rechner Gamma[1.46164]-Gamma[1.46163] ein und dann nochmal Gamma[1.46162]-Gamma[1.46163]. Da kommt beide Male was positives bei raus, also liegt der Wert bei 1.46163 „tiefer“ als die beiden „benachbarten“.

Das hatte ich schon befürchtet. Das wird nicht einfach, weil du arge Probleme mit der Genauigkeit der Fließkommaoperationen bekommen wirst. Du hast ja keine Stammfunktion, um das bestimmte Integral analytisch berechnen zu können und musst daher numerisch rechnen, was alles andere als trivial ist (ich erinnere mich da an Numerik-Vorlesungen. Und da haben wir Matlab benutzt, was für solche Dinge geschaffen wurde…)

Sowas wirst du nicht finden.

Vielleicht kannst du aber eine Taylorreihe (oder eine andere Approximation - so tief steck ich da nicht drin) aufstellen, mit welcher du näherungsweise rechnen kannst.

[QUOTE=cmrudolph]
Das hatte ich schon befürchtet. Das wird nicht einfach, weil du arge Probleme mit der Genauigkeit der Fließkommaoperationen bekommen wirst. Du hast ja keine Stammfunktion, um das bestimmte Integral analytisch berechnen zu können und musst daher numerisch rechnen, was alles andere als trivial ist (ich erinnere mich da an Numerik-Vorlesungen. Und da haben wir Matlab benutzt, was für solche Dinge geschaffen wurde…)[/QUOTE]

Auch wenn es grausam aussieht, hat man immer noch BigDecimal

[QUOTE=cmrudolph]Sowas wirst du nicht finden.[/QUOTE]Grrr… kein Wunder, dass ich mir ein Wolf suche… Naja trotzdem Danke.

Damit hat man zwar eine höhere Genauigkeit, bei einem Integral von 0 bis Unendlich wird das dann aber wahrscheinlich ohne einen vernünftigen Algorithmus beliebig langsam.