std::cyl_neumann, std::cyl_neumannf, std::cyl_neumannl

Definiert in der Header-Datei `<cmath>`
	(1)
float double cyl_neumann ( double nu, double x ); long double cyl_neumann ( long double nu, long double x );			(seit C++17) (bis C++23)
/* floating-point-type / cyl_neumann( / floating-point-type / nu, / Gleitkommazahl-Typ */ x );			(seit C++23)
float cyl_neumannf( float nu, float x );		(2)	(seit C++17)
long double cyl_neumannl( long double nu, long double x );		(3)	(seit C++17)
Zusätzliche Überladungen
Definiert in der Header-Datei `<cmath>`
template< class Arithmetic1, class Arithmetic2 > /* common-floating-point-type */ cyl_neumann( Arithmetic1 nu, Arithmetic2 x );		(A)	(seit C++17)

1-3) Berechnet die Zylinder-Neumann-Funktion (auch bekannt als Besselfunktion zweiter Art oder Weber-Funktion) von nu und x. Die Bibliothek stellt Überladungen von std::cyl_neumann für alle cv-unqualifizierten Gleitkommatypen als Typ der Parameter nu und x bereit.(seit C++23)

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

[bearbeiten] Parameter

nu	-	die Ordnung der Funktion
x	-	das Argument der Funktion

[bearbeiten] Rückgabewert

Wenn keine Fehler auftreten, wird der Wert der Zylinder-Neumann-Funktion (Besselfunktion zweiter Art) von nu und x zurückgegeben, d. h.

N nu (x) = J nu (x)cos(nuπ)-J -nu (x) sin(nuπ)

(wobei

J nu (x)

std::cyl_bessel_j(nu, x) ist) für

x\geq0

und nicht-ganzzahliges nu; für ganzzahliges nu wird ein Grenzwert verwendet.

[bearbeiten] Fehlerbehandlung

Fehler können wie in math_errhandling angegeben gemeldet werden.

Wenn das Argument NaN ist, wird NaN zurückgegeben und kein Domänenfehler gemeldet.
Wenn $nu\geq128$ , ist das Verhalten implementierungsabhängig.

[bearbeiten] Hinweise

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.

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 den Typ long double hat, dann hat std::cyl_neumann(num1, num2) denselben Effekt wie std::cyl_neumann(static_cast<long double>(num1),
static_cast<long double>(num2)).
Andernfalls, wenn num1 und/oder num2 den Typ double oder einen ganzzahligen Typ haben, dann hat std::cyl_neumann(num1, num2) denselben Effekt wie std::cyl_neumann(static_cast<double>(num1),
static_cast<double>(num2)).
Andernfalls, wenn num1 oder num2 den Typ float hat, dann hat std::cyl_neumann(num1, num2) denselben Effekt wie std::cyl_neumann(static_cast<float>(num1),
static_cast<float>(num2)).

(bis C++23)

Wenn num1 und num2 arithmetische Typen haben, dann hat std::cyl_neumann(num1, num2) denselben Effekt wie std::cyl_neumann(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 ganzzahligen Typ werden so betrachtet, als hätten sie denselben Gleitkomma-Konversionsrang wie double.

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)

[bearbeiten] Beispiel

Führen Sie diesen Code aus

#include <cassert>
#include <cmath>
#include <iostream>
#include <numbers>
 
const double π = std::numbers::pi; // or std::acos(-1) in pre C++20
 
// To calculate the cylindrical Neumann function via cylindrical Bessel function of the
// first kind we have to implement J, because the direct invocation of the
// std::cyl_bessel_j(nu, x), per formula above,
// for negative nu raises 'std::domain_error': Bad argument in __cyl_bessel_j.
 
double J_neg(double nu, double x)
{
    return std::cos(-nu * π) * std::cyl_bessel_j(-nu, x)
          -std::sin(-nu * π) * std::cyl_neumann(-nu, x);
}
 
double J_pos(double nu, double x)
{
    return std::cyl_bessel_j(nu, x);
}
 
double J(double nu, double x)
{
    return nu < 0.0 ? J_neg(nu, x) : J_pos(nu, x);
}
 
int main()
{
    std::cout << "spot checks for nu == 0.5\n" << std::fixed << std::showpos;
    const double nu = 0.5;
    for (double x = 0.0; x <= 2.0; x += 0.333)
    {
        const double n = std::cyl_neumann(nu, x);
        const double j = (J(nu, x) * std::cos(nu * π) - J(-nu, x)) / std::sin(nu * π);
        std::cout << "N_.5(" << x << ") = " << n << ", calculated via J = " << j << '\n';
        assert(n == j);
    }
}

Ausgabe

spot checks for nu == 0.5
N_.5(+0.000000) = -inf, calculated via J = -inf
N_.5(+0.333000) = -1.306713, calculated via J = -1.306713
N_.5(+0.666000) = -0.768760, calculated via J = -0.768760
N_.5(+0.999000) = -0.431986, calculated via J = -0.431986
N_.5(+1.332000) = -0.163524, calculated via J = -0.163524
N_.5(+1.665000) = +0.058165, calculated via J = +0.058165
N_.5(+1.998000) = +0.233876, calculated via J = +0.233876

[bearbeiten] Siehe auch

cyl_bessel_icyl_bessel_ifcyl_bessel_il (C++17)(C++17)(C++17)	reguläre modifizierte zylindrische Besselfunktionen (Funktion) [bearbeiten]
cyl_bessel_jcyl_bessel_jfcyl_bessel_jl (C++17)(C++17)(C++17)	zylindrische Besselfunktionen (erster Art) (Funktion) [bearbeiten]
cyl_bessel_kcyl_bessel_kfcyl_bessel_kl (C++17)(C++17)(C++17)	irreguläre modifizierte zylindrische Besselfunktionen (Funktion) [bearbeiten]

[bearbeiten] Externe Links

Weisstein, Eric W. "Bessel Function of the Second Kind." Aus MathWorld – Eine Wolfram-Webressource.

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

cppreference.com

Namensräume

Varianten

Ansichten

Aktionen