std::beta, std::betaf, std::betal

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Numerik-Bibliothek

Allgemeine mathematische Funktionen
Mathematische Spezialfunktionen (C++17)
Mathematische Konstanten (C++20)
Grundlegende lineare Algebra-Algorithmen (C++26)
Datenparallele Typen (SIMD) (C++26)
Gleitkomma-Umgebung (C++11)
Komplexe Zahlen
Numerische Arrays (valarray)
Pseudozufallszahlengenerierung
Bit-Manipulation (C++20)
Faktoroperationen
gcd (C++17)	lcm (C++17)
Interpolationen
midpoint (C++20)	lerp (C++20)
Sättigungsarithmetik
add_sat (C++26) sub_sat (C++26) saturate_cast (C++26)	mul_sat (C++26) div_sat (C++26)
Generische numerische Operationen
iota (C++11) ranges::iota (C++23) accumulate inner_product adjacent_difference    partial_sum	reduce (C++17) transform_reduce (C++17) inclusive_scan (C++17) exclusive_scan (C++17) transform_inclusive_scan (C++17) transform_exclusive_scan (C++17)

 

Mathematische Spezialfunktionen

assoc_laguerreassoc_laguerrefassoc_laguerrel   assoc_legendreassoc_legendrefassoc_legendrel betabetafbetal comp_ellint_1comp_ellint_1fcomp_ellint_1l comp_ellint_2comp_ellint_2fcomp_ellint_2l comp_ellint_3comp_ellint_3fcomp_ellint_3l cyl_bessel_icyl_bessel_ifcyl_bessel_il

cyl_bessel_jcyl_bessel_jfcyl_bessel_jl   cyl_bessel_kcyl_bessel_kfcyl_bessel_kl cyl_neumanncyl_neumannfcyl_neumannl ellint_1ellint_1fellint_1l ellint_2ellint_2fellint_2l ellint_3ellint_3fellint_3l expintexpintfexpintl

hermitehermitefhermitel laguerrelaguerreflaguerrel legendrelegendreflegendrel riemann_zetariemann_zetafriemann_zetal sph_besselsph_besselfsph_bessell sph_legendresph_legendrefsph_legendrel sph_neumannsph_neumannfsph_neumannl

 

Definiert in der Header-Datei <cmath>
	(1)
float       beta ( float x, float y ); double      beta ( double x, double y ); long double beta ( long double x, long double y );			(seit C++17) (bis C++23)
/* floating-point-type */ beta( /* floating-point-type */ x,                                 /* floating-point-type */ y );			(seit C++23)
float       betaf( float x, float y );		(2)	(seit C++17)
long double betal( long double x, long double y );		(3)	(seit C++17)
Zusätzliche Überladungen
Definiert in der Header-Datei <cmath>
template< class Arithmetic1, class Arithmetic2 > /* common-floating-point-type */ beta( Arithmetic1 x, Arithmetic2 y );		(A)	(seit C++17)

1-3) Berechnet die Beta-Funktion von x und y. Die Bibliothek stellt Überladungen von std::beta für alle cv-unqualifizierten Gleitkommatypen als Typ der Parameter x und y bereit.(seit C++23)

A) Zusätzliche Überladungen werden für alle anderen Kombinationen von arithmetischen Typen bereitgestellt.

Parameter

x, y

-

Gleitkomma- oder Ganzzahlwerte

Rückgabewert

Wenn keine Fehler auftreten, wird der Wert der Beta-Funktion von x und y zurückgegeben, d.h. \(\int_{0}^{1}{ {t}^{x-1}{(1-t)}^{y-1}\mathsf{d}t}\)∫1
0tx-1
(1-t)(y-1)
dt, oder äquivalent \(\frac{\Gamma(x)\Gamma(y)}{\Gamma(x+y)}\)

Γ(x)Γ(y)

Γ(x+y)

.

Fehlerbehandlung

Fehler können wie in math_errhandling angegeben gemeldet werden.

• Wenn ein Argument NaN ist, wird NaN zurückgegeben und kein Domänenfehler gemeldet.
• Die Funktion muss nur dort definiert sein, wo sowohl x als auch y größer als Null sind, und darf andernfalls einen Domänenfehler melden.

Anmerkungen

Implementierungen, die C++17 nicht unterstützen, aber ISO 29124:2010 unterstützen, stellen diese Funktion bereit, wenn __STDCPP_MATH_SPEC_FUNCS__ von der Implementierung auf einen Wert von mindestens 201003L definiert wird und wenn der Benutzer __STDCPP_WANT_MATH_SPEC_FUNCS__ definiert, bevor er beliebige Standardbibliotheks-Header einschließt.

Implementierungen, die ISO 29124:2010 nicht unterstützen, aber TR 19768:2007 (TR1) unterstützen, stellen diese Funktion im Header tr1/cmath im Namespace std::tr1 bereit.

Eine Implementierung dieser Funktion ist auch in boost.math verfügbar.

std::beta(x, y) ist gleich std::beta(y, x).

Wenn x und y positive ganze Zahlen sind, ist std::beta(x, y) gleich \(\frac{(x-1)!(y-1)!}{(x+y-1)!}\)

(x-1)!(y-1)!

(x+y-1)!

. Binomialkoeffizienten können durch die Beta-Funktion ausgedrückt werden: \(\binom{n}{k} = \frac{1}{(n+1)B(n-k+1,k+1)}\)⎛
⎜
⎝n
k⎞
⎟
⎠=

1

(n+1)Β(n-k+1,k+1)

.

Die zusätzlichen Überladungen müssen nicht exakt wie (A) angegeben werden. Sie müssen nur ausreichen, um sicherzustellen, dass für ihr erstes Argument num1 und ihr zweites Argument num2

Wenn num1 oder num2 vom Typ long double ist, hat std::beta(num1, num2) den gleichen Effekt wie std::beta(static_cast<long double>(num1),           static_cast<long double>(num2)). Andernfalls, wenn num1 und/oder num2 vom Typ double oder einem Ganzzahltyp ist, hat std::beta(num1, num2) den gleichen Effekt wie std::beta(static_cast<double>(num1),           static_cast<double>(num2)). Andernfalls, wenn num1 oder num2 vom Typ float ist, hat std::beta(num1, num2) den gleichen Effekt wie std::beta(static_cast<float>(num1),           static_cast<float>(num2)).

(bis C++23)

Wenn num1 und num2 arithmetische Typen haben, hat std::beta(num1, num2) den gleichen Effekt wie std::beta(static_cast</* common-floating-point-type */>(num1),           static_cast</* common-floating-point-type */>(num2)), wobei /* common-floating-point-type */ der Gleitkommatyp mit dem höchsten Gleitkomma-Konversionsrang und dem höchsten Gleitkomma-Konversions-Subrang zwischen den Typen von num1 und num2 ist. Argumente vom Ganzzahltyp werden als Gleitkomma-Konversionsrang wie double betrachtet. Wenn kein solcher Gleitkommazahltyp mit dem höchsten Rang und Subrang existiert, dann führt die Überladungsauflösung nicht zu einem nutzbaren Kandidaten aus den bereitgestellten Überladungen.

(seit C++23)

Beispiel

Führen Sie diesen Code aus

#include <cassert>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <numbers>
#include <string>
 
long binom_via_beta(int n, int k)
{
    return std::lround(1 / ((n + 1) * std::beta(n - k + 1, k + 1)));
}
 
long binom_via_gamma(int n, int k)
{
    return std::lround(std::tgamma(n + 1) /
                      (std::tgamma(n - k + 1) * 
                       std::tgamma(k + 1)));
}
 
int main()
{
    std::cout << "Pascal's triangle:\n";
    for (int n = 1; n < 10; ++n)
    {
        std::cout << std::string(20 - n * 2, ' ');
        for (int k = 1; k < n; ++k)
        {
            std::cout << std::setw(3) << binom_via_beta(n, k) << ' ';
            assert(binom_via_beta(n, k) == binom_via_gamma(n, k));
        }
        std::cout << '\n';
    }
 
    // A spot-check
    const long double p = 0.123; // a random value in [0, 1]
    const long double q = 1 - p;
    const long double π = std::numbers::pi_v<long double>;
    std::cout << "\n\n" << std::setprecision(19)
              << "β(p,1-p)   = " << std::beta(p, q) << '\n'
              << "π/sin(π*p) = " << π / std::sin(π * p) << '\n';
}

Ausgabe

Pascal's triangle:
 
                  2
                3   3
              4   6   4
            5  10  10   5
          6  15  20  15   6
        7  21  35  35  21   7
      8  28  56  70  56  28   8
    9  36  84 126 126  84  36   9
 
β(p,1-p)   = 8.335989149587307836
π/sin(π*p) = 8.335989149587307834

Siehe auch

tgammatgammaftgammal (C++11)(C++11)(C++11)

Gammafunktion (Funktion)

Externe Links

Weisstein, Eric W. "Beta Function." Von MathWorld – Eine Wolfram Web Resource.