//! Canonical reviewed raw scalar special-function declarations.
//!
//! This file is generated by `slatec-corpus generate-raw-api-inventory --offline`.
//! Each promoted special subfamily has its own source-hash-guarded review policy
//! and re-exports one private authoritative declaration.
/// Reviewed scalar special-function routines in the `elementary` group.
#[cfg(any(
feature = "special-elementary",
feature = "raw-family-special-elementary"
))]
pub mod elementary {
// raw-api-routine: ALNREL
/// Original SLATEC routine `ALNREL`.
/// Evaluates `ln(1 + x)` with relative-error accuracy near zero.
/// Mathematical operation: natural logarithm of one plus the argument.
/// Precision and return ABI: `f32` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: `X` must be greater than `-1`; extremely small positive `1 + X` can report loss of precision.
/// Selected provider: `full-provider-7b8a94d5a46444f3`; source: <https://www.netlib.org/slatec/fnlib/alnrel.f>; native symbol: `alnrel_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, the value is read only, and it must satisfy the routine's documented domain.
///
/// # Native behavior
/// The selected source reports documented domain, overflow, underflow, or precision conditions through legacy XERROR/XERMSG; a raw caller must avoid fatal configurations and does not receive a Rust error value.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/alnrel.md"))]
pub use crate::families::special_elementary::alnrel;
// raw-api-routine: CBRT
/// Original SLATEC routine `CBRT`.
/// Computes the real cube root.
/// Mathematical operation: real cube root.
/// Precision and return ABI: `f32` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: finite real inputs are supported, including negative values and zero.
/// Selected provider: `full-provider-1533f97ac6fe4af0`; source: <https://www.netlib.org/slatec/fnlib/cbrt.f>; native symbol: `cbrt_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, the value is read only, and it must satisfy the routine's documented domain.
///
/// # Native behavior
/// The source uses machine constants but documents no routine-specific XERROR domain rejection for ordinary finite inputs.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/cbrt.md"))]
pub use crate::families::special_elementary::cbrt;
// raw-api-routine: COSDG
/// Original SLATEC routine `COSDG`.
/// Computes cosine with the argument expressed in degrees.
/// Mathematical operation: cosine of degrees converted to radians.
/// Precision and return ABI: `f32` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: ordinary finite real degree arguments are supported; very large magnitudes inherit native argument-reduction precision limits.
/// Selected provider: `full-provider-83eee5b10e647302`; source: <https://www.netlib.org/slatec/fnlib/cosdg.f>; native symbol: `cosdg_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, the value is read only, and it must satisfy the routine's documented domain.
///
/// # Native behavior
/// The source does not report ordinary finite inputs through XERROR.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/cosdg.md"))]
pub use crate::families::special_elementary::cosdg;
// raw-api-routine: DAWS
/// Original SLATEC routine `DAWS`.
/// Computes Dawson's integral for a real argument.
/// Mathematical operation: exp(-x²) times the integral of exp(t²) from zero to x.
/// Precision and return ABI: `f32` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: finite real inputs are supported; sufficiently large magnitude can underflow and report through XERROR.
/// Selected provider: `full-provider-d910a32a69a9b3ef`; source: <https://www.netlib.org/slatec/fnlib/daws.f>; native symbol: `daws_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, the value is read only, and it must satisfy the routine's documented domain.
///
/// # Native behavior
/// The selected source reports documented domain, overflow, underflow, or precision conditions through legacy XERROR/XERMSG; a raw caller must avoid fatal configurations and does not receive a Rust error value.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/daws.md"))]
pub use crate::families::special_elementary::daws;
// raw-api-routine: DCBRT
/// Original SLATEC routine `DCBRT`.
/// Computes the double-precision real cube root.
/// Mathematical operation: real cube root.
/// Precision and return ABI: `f64` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: finite real inputs are supported, including negative values and zero.
/// Selected provider: `full-provider-5a4730fc04f83be8`; source: <https://www.netlib.org/slatec/fnlib/dcbrt.f>; native symbol: `dcbrt_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, the value is read only, and it must satisfy the routine's documented domain.
///
/// # Native behavior
/// The source uses machine constants but documents no routine-specific XERROR domain rejection for ordinary finite inputs.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dcbrt.md"))]
pub use crate::families::special_elementary::dcbrt;
// raw-api-routine: DCOSDG
/// Original SLATEC routine `DCOSDG`.
/// Computes double-precision cosine with the argument expressed in degrees.
/// Mathematical operation: cosine of degrees converted to radians.
/// Precision and return ABI: `f64` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: ordinary finite real degree arguments are supported; very large magnitudes inherit native argument-reduction precision limits.
/// Selected provider: `full-provider-03079b5f6ef2df31`; source: <https://www.netlib.org/slatec/fnlib/dcosdg.f>; native symbol: `dcosdg_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, the value is read only, and it must satisfy the routine's documented domain.
///
/// # Native behavior
/// The source does not report ordinary finite inputs through XERROR.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dcosdg.md"))]
pub use crate::families::special_elementary::dcosdg;
// raw-api-routine: DDAWS
/// Original SLATEC routine `DDAWS`.
/// Computes the double-precision Dawson integral.
/// Mathematical operation: exp(-x²) times the integral of exp(t²) from zero to x.
/// Precision and return ABI: `f64` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: finite real inputs are supported; sufficiently large magnitude can underflow and report through XERROR.
/// Selected provider: `full-provider-6b1c0a77e9609e2e`; source: <https://www.netlib.org/slatec/fnlib/ddaws.f>; native symbol: `ddaws_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, the value is read only, and it must satisfy the routine's documented domain.
///
/// # Native behavior
/// The selected source reports documented domain, overflow, underflow, or precision conditions through legacy XERROR/XERMSG; a raw caller must avoid fatal configurations and does not receive a Rust error value.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/ddaws.md"))]
pub use crate::families::special_elementary::ddaws;
// raw-api-routine: DEXPRL
/// Original SLATEC routine `DEXPRL`.
/// Computes the relative exponential accurately near zero.
/// Mathematical operation: (exp(x) - 1) / x with the continuous value one at zero.
/// Precision and return ABI: `f64` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: finite real inputs are supported; large positive inputs can overflow in the native exponential.
/// Selected provider: `full-provider-528bf34b2aa77472`; source: <https://www.netlib.org/slatec/fnlib/dexprl.f>; native symbol: `dexprl_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, the value is read only, and it must satisfy the routine's documented domain.
///
/// # Native behavior
/// The source uses machine constants; overflow follows the native floating-point/runtime behavior.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dexprl.md"))]
pub use crate::families::special_elementary::dexprl;
// raw-api-routine: DLNREL
/// Original SLATEC routine `DLNREL`.
/// Evaluates double-precision `ln(1 + x)` with relative-error accuracy near zero.
/// Mathematical operation: natural logarithm of one plus the argument.
/// Precision and return ABI: `f64` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: `X` must be greater than `-1`; extremely small positive `1 + X` can report loss of precision.
/// Selected provider: `full-provider-e558c4161d7ec74f`; source: <https://www.netlib.org/slatec/fnlib/dlnrel.f>; native symbol: `dlnrel_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, the value is read only, and it must satisfy the routine's documented domain.
///
/// # Native behavior
/// The selected source reports documented domain, overflow, underflow, or precision conditions through legacy XERROR/XERMSG; a raw caller must avoid fatal configurations and does not receive a Rust error value.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dlnrel.md"))]
pub use crate::families::special_elementary::dlnrel;
// raw-api-routine: DSINDG
/// Original SLATEC routine `DSINDG`.
/// Computes double-precision sine with the argument expressed in degrees.
/// Mathematical operation: sine of degrees converted to radians.
/// Precision and return ABI: `f64` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: ordinary finite real degree arguments are supported; very large magnitudes inherit native argument-reduction precision limits.
/// Selected provider: `full-provider-7eea1cc313807214`; source: <https://www.netlib.org/slatec/fnlib/dsindg.f>; native symbol: `dsindg_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, the value is read only, and it must satisfy the routine's documented domain.
///
/// # Native behavior
/// The source does not report ordinary finite inputs through XERROR.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dsindg.md"))]
pub use crate::families::special_elementary::dsindg;
// raw-api-routine: EXPREL
/// Original SLATEC routine `EXPREL`.
/// Computes the relative exponential accurately near zero.
/// Mathematical operation: (exp(x) - 1) / x with the continuous value one at zero.
/// Precision and return ABI: `f32` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: finite real inputs are supported; large positive inputs can overflow in the native exponential.
/// Selected provider: `full-provider-31cd8d541d1bfb0d`; source: <https://www.netlib.org/slatec/fnlib/exprel.f>; native symbol: `exprel_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, the value is read only, and it must satisfy the routine's documented domain.
///
/// # Native behavior
/// The source uses machine constants; overflow follows the native floating-point/runtime behavior.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/exprel.md"))]
pub use crate::families::special_elementary::exprel;
// raw-api-routine: SINDG
/// Original SLATEC routine `SINDG`.
/// Computes sine with the argument expressed in degrees.
/// Mathematical operation: sine of degrees converted to radians.
/// Precision and return ABI: `f32` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: ordinary finite real degree arguments are supported; very large magnitudes inherit native argument-reduction precision limits.
/// Selected provider: `full-provider-8592a526281289c2`; source: <https://www.netlib.org/slatec/fnlib/sindg.f>; native symbol: `sindg_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, the value is read only, and it must satisfy the routine's documented domain.
///
/// # Native behavior
/// The source does not report ordinary finite inputs through XERROR.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/sindg.md"))]
pub use crate::families::special_elementary::sindg;
}
/// Reviewed scalar special-function routines in the `gamma` group.
#[cfg(any(feature = "special-gamma", feature = "raw-family-special-gamma"))]
pub mod gamma {
// raw-api-routine: ALNGAM
/// Original SLATEC routine `ALNGAM`.
/// Computes the logarithm of the absolute value of Gamma.
/// Mathematical operation: ln(abs(Gamma(x))).
/// Precision and return ABI: `f32` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: avoid Gamma poles at zero and negative integers, arguments too near a pole, and magnitudes that overflow the selected source range.
/// Selected provider: `full-provider-83754f0e154167cd`; source: <https://www.netlib.org/slatec/fnlib/alngam.f>; native symbol: `alngam_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, the value is read only, and it must satisfy the routine's documented domain.
///
/// # Native behavior
/// The selected source reports documented domain, overflow, underflow, or precision conditions through legacy XERROR/XERMSG; a raw caller must avoid fatal configurations and does not receive a Rust error value.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/alngam.md"))]
pub use crate::families::special_gamma::alngam;
// raw-api-routine: BINOM
/// Original SLATEC routine `BINOM`.
/// Computes a binomial coefficient.
/// Mathematical operation: N! / (M! (N-M)!).
/// Precision and return ABI: `f32` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: requires integer `N >= 0` and `0 <= M <= N`; a result outside the native finite range reports overflow.
/// Selected provider: `full-provider-1c9778aa4f113fe6`; source: <https://www.netlib.org/slatec/fnlib/binom.f>; native symbol: `binom_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `N`: input `FortranInteger`, passed by address; null is not permitted, the value is read only, and it must be non-negative and within the routine's finite-result range.
/// - `M`: input `FortranInteger`, passed by address; null is not permitted, the value is read only, and it must satisfy `0 <= M <= N`.
///
/// # Native behavior
/// The selected source reports documented domain, overflow, underflow, or precision conditions through legacy XERROR/XERMSG; a raw caller must avoid fatal configurations and does not receive a Rust error value.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/binom.md"))]
pub use crate::families::special_gamma::binom;
// raw-api-routine: DBINOM
/// Original SLATEC routine `DBINOM`.
/// Computes a double-precision binomial coefficient.
/// Mathematical operation: N! / (M! (N-M)!).
/// Precision and return ABI: `f64` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: requires integer `N >= 0` and `0 <= M <= N`; a result outside the native finite range reports overflow.
/// Selected provider: `full-provider-b1848abc902b2451`; source: <https://www.netlib.org/slatec/fnlib/dbinom.f>; native symbol: `dbinom_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `N`: input `FortranInteger`, passed by address; null is not permitted, the value is read only, and it must be non-negative and within the routine's finite-result range.
/// - `M`: input `FortranInteger`, passed by address; null is not permitted, the value is read only, and it must satisfy `0 <= M <= N`.
///
/// # Native behavior
/// The selected source reports documented domain, overflow, underflow, or precision conditions through legacy XERROR/XERMSG; a raw caller must avoid fatal configurations and does not receive a Rust error value.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dbinom.md"))]
pub use crate::families::special_gamma::dbinom;
// raw-api-routine: DFAC
/// Original SLATEC routine `DFAC`.
/// Computes a double-precision factorial.
/// Mathematical operation: N factorial.
/// Precision and return ABI: `f64` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: requires integer `N >= 0` and a result within the native finite range.
/// Selected provider: `full-provider-2d8169aa57e4f3a6`; source: <https://www.netlib.org/slatec/fnlib/dfac.f>; native symbol: `dfac_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `N`: input `FortranInteger`, passed by address; null is not permitted, the value is read only, and it must be non-negative and within the routine's finite-result range.
///
/// # Native behavior
/// The selected source reports documented domain, overflow, underflow, or precision conditions through legacy XERROR/XERMSG; a raw caller must avoid fatal configurations and does not receive a Rust error value.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dfac.md"))]
pub use crate::families::special_gamma::dfac;
// raw-api-routine: DGAMI
/// Original SLATEC routine `DGAMI`.
/// Computes the lower incomplete Gamma integral.
/// Mathematical operation: integral from zero to x of exp(-t) t^(a-1).
/// Precision and return ABI: `f64` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: the reviewed direct-call domain requires `A > 0` and `X >= 0`.
/// Selected provider: `full-provider-6dcf9270d002626b`; source: <https://www.netlib.org/slatec/fnlib/dgami.f>; native symbol: `dgami_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `A`: input real shape parameter, passed by address; null is not permitted, the value is read only, and the reviewed direct-call domain requires `A > 0`.
/// - `X`: input real scalar, passed by address; null is not permitted, the value is read only, and it must satisfy the routine's documented domain.
///
/// # Native behavior
/// The selected source reports documented domain, overflow, underflow, or precision conditions through legacy XERROR/XERMSG; a raw caller must avoid fatal configurations and does not receive a Rust error value.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dgami.md"))]
pub use crate::families::special_gamma::dgami;
// raw-api-routine: DGAMIC
/// Original SLATEC routine `DGAMIC`.
/// Computes the complementary incomplete Gamma integral.
/// Mathematical operation: integral from x to infinity of exp(-t) t^(a-1).
/// Precision and return ABI: `f64` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: the reviewed direct-call domain requires `A > 0` and `X >= 0`; near-cancellation or underflow can be reported.
/// Selected provider: `full-provider-418c630a1935a331`; source: <https://www.netlib.org/slatec/fnlib/dgamic.f>; native symbol: `dgamic_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `A`: input real shape parameter, passed by address; null is not permitted, the value is read only, and the reviewed direct-call domain requires `A > 0`.
/// - `X`: input real scalar, passed by address; null is not permitted, the value is read only, and it must satisfy the routine's documented domain.
///
/// # Native behavior
/// The selected source reports documented domain, overflow, underflow, or precision conditions through legacy XERROR/XERMSG; a raw caller must avoid fatal configurations and does not receive a Rust error value.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dgamic.md"))]
pub use crate::families::special_gamma::dgamic;
// raw-api-routine: DGAMIT
/// Original SLATEC routine `DGAMIT`.
/// Computes Tricomi's incomplete Gamma function.
/// Mathematical operation: x^(-a) times the lower incomplete Gamma integral.
/// Precision and return ABI: `f64` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: the reviewed direct-call domain requires `A > 0` and `X >= 0`; do not assume unreviewed analytic-continuation behavior.
/// Selected provider: `full-provider-ef0b5f035cb82912`; source: <https://www.netlib.org/slatec/fnlib/dgamit.f>; native symbol: `dgamit_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `A`: input real shape parameter, passed by address; null is not permitted, the value is read only, and the reviewed direct-call domain requires `A > 0`.
/// - `X`: input real scalar, passed by address; null is not permitted, the value is read only, and it must satisfy the routine's documented domain.
///
/// # Native behavior
/// The selected source reports documented domain, overflow, underflow, or precision conditions through legacy XERROR/XERMSG; a raw caller must avoid fatal configurations and does not receive a Rust error value.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dgamit.md"))]
pub use crate::families::special_gamma::dgamit;
// raw-api-routine: DGAMMA
/// Original SLATEC routine `DGAMMA`.
/// Computes the complete Gamma function.
/// Mathematical operation: Gamma(x).
/// Precision and return ABI: `f64` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: `X` must not be zero or a negative integer; avoid arguments too near a pole and values whose result overflows or underflows.
/// Selected provider: `full-provider-fba63d75b3e077b9`; source: <https://www.netlib.org/slatec/fnlib/dgamma.f>; native symbol: `dgamma_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, the value is read only, and it must satisfy the routine's documented domain.
///
/// # Native behavior
/// The selected source reports documented domain, overflow, underflow, or precision conditions through legacy XERROR/XERMSG; a raw caller must avoid fatal configurations and does not receive a Rust error value.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dgamma.md"))]
pub use crate::families::special_gamma::dgamma;
// raw-api-routine: DGAMR
/// Original SLATEC routine `DGAMR`.
/// Computes the reciprocal Gamma function.
/// Mathematical operation: 1 / Gamma(x).
/// Precision and return ABI: `f64` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: finite real arguments are supported by the selected source; nonpositive integer poles produce its documented zero result, while near-pole and range behavior remains native.
/// Selected provider: `full-provider-8e5b160bb1bc03a8`; source: <https://www.netlib.org/slatec/fnlib/dgamr.f>; native symbol: `dgamr_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, the value is read only, and it must satisfy the routine's documented domain.
///
/// # Native behavior
/// The implementation deliberately suppresses selected Gamma diagnostics with XERCLR while evaluating its result; callers must account for legacy XERROR state.
/// This routine reads and temporarily changes legacy XERROR control with XGETF/XSETF and clears selected reports with XERCLR; serialize it with every other call that can use the legacy error runtime.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dgamr.md"))]
pub use crate::families::special_gamma::dgamr;
// raw-api-routine: DLNGAM
/// Original SLATEC routine `DLNGAM`.
/// Computes the logarithm of the absolute value of double-precision Gamma.
/// Mathematical operation: ln(abs(Gamma(x))).
/// Precision and return ABI: `f64` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: avoid Gamma poles at zero and negative integers, arguments too near a pole, and magnitudes outside the selected source range.
/// Selected provider: `full-provider-dae73c5ac3d5f638`; source: <https://www.netlib.org/slatec/fnlib/dlngam.f>; native symbol: `dlngam_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, the value is read only, and it must satisfy the routine's documented domain.
///
/// # Native behavior
/// The selected source reports documented domain, overflow, underflow, or precision conditions through legacy XERROR/XERMSG; a raw caller must avoid fatal configurations and does not receive a Rust error value.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dlngam.md"))]
pub use crate::families::special_gamma::dlngam;
// raw-api-routine: DPSI
/// Original SLATEC routine `DPSI`.
/// Computes the double-precision digamma function.
/// Mathematical operation: derivative of ln(Gamma(x)).
/// Precision and return ABI: `f64` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: `X` must not be zero or a negative integer; avoid values too near a pole.
/// Selected provider: `full-provider-d7f4380fe713f6a0`; source: <https://www.netlib.org/slatec/fnlib/dpsi.f>; native symbol: `dpsi_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, the value is read only, and it must satisfy the routine's documented domain.
///
/// # Native behavior
/// The selected source reports documented domain, overflow, underflow, or precision conditions through legacy XERROR/XERMSG; a raw caller must avoid fatal configurations and does not receive a Rust error value.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dpsi.md"))]
pub use crate::families::special_gamma::dpsi;
// raw-api-routine: FAC
/// Original SLATEC routine `FAC`.
/// Computes a factorial.
/// Mathematical operation: N factorial.
/// Precision and return ABI: `f32` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: requires integer `N >= 0` and a result within the native finite range.
/// Selected provider: `full-provider-5a5153512db1c25b`; source: <https://www.netlib.org/slatec/fnlib/fac.f>; native symbol: `fac_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `N`: input `FortranInteger`, passed by address; null is not permitted, the value is read only, and it must be non-negative and within the routine's finite-result range.
///
/// # Native behavior
/// The selected source reports documented domain, overflow, underflow, or precision conditions through legacy XERROR/XERMSG; a raw caller must avoid fatal configurations and does not receive a Rust error value.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/fac.md"))]
pub use crate::families::special_gamma::fac;
// raw-api-routine: GAMI
/// Original SLATEC routine `GAMI`.
/// Computes the lower incomplete Gamma integral.
/// Mathematical operation: integral from zero to x of exp(-t) t^(a-1).
/// Precision and return ABI: `f32` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: the reviewed direct-call domain requires `A > 0` and `X >= 0`.
/// Selected provider: `full-provider-17ee5a4415667186`; source: <https://www.netlib.org/slatec/fnlib/gami.f>; native symbol: `gami_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `A`: input real shape parameter, passed by address; null is not permitted, the value is read only, and the reviewed direct-call domain requires `A > 0`.
/// - `X`: input real scalar, passed by address; null is not permitted, the value is read only, and it must satisfy the routine's documented domain.
///
/// # Native behavior
/// The selected source reports documented domain, overflow, underflow, or precision conditions through legacy XERROR/XERMSG; a raw caller must avoid fatal configurations and does not receive a Rust error value.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/gami.md"))]
pub use crate::families::special_gamma::gami;
// raw-api-routine: GAMIC
/// Original SLATEC routine `GAMIC`.
/// Computes the complementary incomplete Gamma integral.
/// Mathematical operation: integral from x to infinity of exp(-t) t^(a-1).
/// Precision and return ABI: `f32` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: the reviewed direct-call domain requires `A > 0` and `X >= 0`; near-cancellation or underflow can be reported.
/// Selected provider: `full-provider-0e43010ee0036089`; source: <https://www.netlib.org/slatec/fnlib/gamic.f>; native symbol: `gamic_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `A`: input real shape parameter, passed by address; null is not permitted, the value is read only, and the reviewed direct-call domain requires `A > 0`.
/// - `X`: input real scalar, passed by address; null is not permitted, the value is read only, and it must satisfy the routine's documented domain.
///
/// # Native behavior
/// The selected source reports documented domain, overflow, underflow, or precision conditions through legacy XERROR/XERMSG; a raw caller must avoid fatal configurations and does not receive a Rust error value.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/gamic.md"))]
pub use crate::families::special_gamma::gamic;
// raw-api-routine: GAMIT
/// Original SLATEC routine `GAMIT`.
/// Computes Tricomi's incomplete Gamma function.
/// Mathematical operation: x^(-a) times the lower incomplete Gamma integral.
/// Precision and return ABI: `f32` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: the reviewed direct-call domain requires `A > 0` and `X >= 0`; do not assume unreviewed analytic-continuation behavior.
/// Selected provider: `full-provider-ef6b55c5116aaeb2`; source: <https://www.netlib.org/slatec/fnlib/gamit.f>; native symbol: `gamit_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `A`: input real shape parameter, passed by address; null is not permitted, the value is read only, and the reviewed direct-call domain requires `A > 0`.
/// - `X`: input real scalar, passed by address; null is not permitted, the value is read only, and it must satisfy the routine's documented domain.
///
/// # Native behavior
/// The selected source reports documented domain, overflow, underflow, or precision conditions through legacy XERROR/XERMSG; a raw caller must avoid fatal configurations and does not receive a Rust error value.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/gamit.md"))]
pub use crate::families::special_gamma::gamit;
// raw-api-routine: GAMMA
/// Original SLATEC routine `GAMMA`.
/// Computes the complete Gamma function.
/// Mathematical operation: Gamma(x).
/// Precision and return ABI: `f32` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: `X` must not be zero or a negative integer; avoid arguments too near a pole and values whose result overflows or underflows.
/// Selected provider: `full-provider-08296fb977fddf71`; source: <https://www.netlib.org/slatec/fnlib/gamma.f>; native symbol: `gamma_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, the value is read only, and it must satisfy the routine's documented domain.
///
/// # Native behavior
/// The selected source reports documented domain, overflow, underflow, or precision conditions through legacy XERROR/XERMSG; a raw caller must avoid fatal configurations and does not receive a Rust error value.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/gamma.md"))]
pub use crate::families::special_gamma::gamma;
// raw-api-routine: GAMR
/// Original SLATEC routine `GAMR`.
/// Computes the reciprocal Gamma function.
/// Mathematical operation: 1 / Gamma(x).
/// Precision and return ABI: `f32` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: finite real arguments are supported by the selected source; nonpositive integer poles produce its documented zero result, while near-pole and range behavior remains native.
/// Selected provider: `full-provider-20a262a4b8f10698`; source: <https://www.netlib.org/slatec/fnlib/gamr.f>; native symbol: `gamr_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, the value is read only, and it must satisfy the routine's documented domain.
///
/// # Native behavior
/// The implementation deliberately suppresses selected Gamma diagnostics with XERCLR while evaluating its result; callers must account for legacy XERROR state.
/// This routine reads and temporarily changes legacy XERROR control with XGETF/XSETF and clears selected reports with XERCLR; serialize it with every other call that can use the legacy error runtime.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/gamr.md"))]
pub use crate::families::special_gamma::gamr;
// raw-api-routine: PSI
/// Original SLATEC routine `PSI`.
/// Computes the digamma function.
/// Mathematical operation: derivative of ln(Gamma(x)).
/// Precision and return ABI: `f32` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: `X` must not be zero or a negative integer; avoid values too near a pole.
/// Selected provider: `full-provider-ab67ae42814fb036`; source: <https://www.netlib.org/slatec/fnlib/psi.f>; native symbol: `psi_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, the value is read only, and it must satisfy the routine's documented domain.
///
/// # Native behavior
/// The selected source reports documented domain, overflow, underflow, or precision conditions through legacy XERROR/XERMSG; a raw caller must avoid fatal configurations and does not receive a Rust error value.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/psi.md"))]
pub use crate::families::special_gamma::psi;
}
/// Reviewed scalar special-function routines in the `beta` group.
#[cfg(any(feature = "special-beta", feature = "raw-family-special-beta"))]
pub mod beta {
// raw-api-routine: ALBETA
/// Original SLATEC routine `ALBETA`.
/// Computes the natural logarithm of the complete Beta function.
/// Mathematical operation: ln(Beta(a, b)).
/// Precision and return ABI: `f32` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: both `A` and `B` must be positive.
/// Selected provider: `full-provider-28d2b9a40c3d9a3e`; source: <https://www.netlib.org/slatec/fnlib/albeta.f>; native symbol: `albeta_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `A`: first input real parameter, passed by address; null is not permitted, the value is read only, and the documented beta-function domain requires it to be positive.
/// - `B`: second input real parameter, passed by address; null is not permitted, the value is read only, and the documented beta-function domain requires it to be positive.
///
/// # Native behavior
/// The selected source reports documented domain, overflow, underflow, or precision conditions through legacy XERROR/XERMSG; a raw caller must avoid fatal configurations and does not receive a Rust error value.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/albeta.md"))]
pub use crate::families::special_beta::albeta;
// raw-api-routine: BETA
/// Original SLATEC routine `BETA`.
/// Computes the complete Beta function.
/// Mathematical operation: Gamma(a) Gamma(b) / Gamma(a + b).
/// Precision and return ABI: `f32` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: both `A` and `B` must be positive; overflow or underflow follows the selected source's XERROR behavior.
/// Selected provider: `full-provider-e4144753752f8572`; source: <https://www.netlib.org/slatec/fnlib/beta.f>; native symbol: `beta_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `A`: first input real parameter, passed by address; null is not permitted, the value is read only, and the documented beta-function domain requires it to be positive.
/// - `B`: second input real parameter, passed by address; null is not permitted, the value is read only, and the documented beta-function domain requires it to be positive.
///
/// # Native behavior
/// The selected source reports documented domain, overflow, underflow, or precision conditions through legacy XERROR/XERMSG; a raw caller must avoid fatal configurations and does not receive a Rust error value.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/beta.md"))]
pub use crate::families::special_beta::beta;
// raw-api-routine: BETAI
/// Original SLATEC routine `BETAI`.
/// Computes the regularized incomplete Beta ratio.
/// Mathematical operation: probability integral of a Beta(PIN, QIN) variate through X.
/// Precision and return ABI: `f32` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: requires `0 <= X <= 1`, `PIN > 0`, and `QIN > 0`.
/// Selected provider: `full-provider-338f4cc19b51c0a6`; source: <https://www.netlib.org/slatec/fnlib/betai.f>; native symbol: `betai_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, the value is read only, and it must satisfy the routine's documented domain.
/// - `PIN`: first positive beta-distribution shape parameter, passed by address; null is not permitted and the value is read only.
/// - `QIN`: second positive beta-distribution shape parameter, passed by address; null is not permitted and the value is read only.
///
/// # Native behavior
/// The selected source reports documented domain, overflow, underflow, or precision conditions through legacy XERROR/XERMSG; a raw caller must avoid fatal configurations and does not receive a Rust error value.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/betai.md"))]
pub use crate::families::special_beta::betai;
// raw-api-routine: DBETA
/// Original SLATEC routine `DBETA`.
/// Computes the double-precision complete Beta function.
/// Mathematical operation: Gamma(a) Gamma(b) / Gamma(a + b).
/// Precision and return ABI: `f64` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: both `A` and `B` must be positive; overflow or underflow follows the selected source's XERROR behavior.
/// Selected provider: `full-provider-c2218e356ca37d3f`; source: <https://www.netlib.org/slatec/fnlib/dbeta.f>; native symbol: `dbeta_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `A`: first input real parameter, passed by address; null is not permitted, the value is read only, and the documented beta-function domain requires it to be positive.
/// - `B`: second input real parameter, passed by address; null is not permitted, the value is read only, and the documented beta-function domain requires it to be positive.
///
/// # Native behavior
/// The selected source reports documented domain, overflow, underflow, or precision conditions through legacy XERROR/XERMSG; a raw caller must avoid fatal configurations and does not receive a Rust error value.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dbeta.md"))]
pub use crate::families::special_beta::dbeta;
// raw-api-routine: DBETAI
/// Original SLATEC routine `DBETAI`.
/// Computes the double-precision regularized incomplete Beta ratio.
/// Mathematical operation: probability integral of a Beta(PIN, QIN) variate through X.
/// Precision and return ABI: `f64` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: requires `0 <= X <= 1`, `PIN > 0`, and `QIN > 0`.
/// Selected provider: `full-provider-676c1bb951f8354f`; source: <https://www.netlib.org/slatec/fnlib/dbetai.f>; native symbol: `dbetai_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, the value is read only, and it must satisfy the routine's documented domain.
/// - `PIN`: first positive beta-distribution shape parameter, passed by address; null is not permitted and the value is read only.
/// - `QIN`: second positive beta-distribution shape parameter, passed by address; null is not permitted and the value is read only.
///
/// # Native behavior
/// The selected source reports documented domain, overflow, underflow, or precision conditions through legacy XERROR/XERMSG; a raw caller must avoid fatal configurations and does not receive a Rust error value.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dbetai.md"))]
pub use crate::families::special_beta::dbetai;
// raw-api-routine: DLBETA
/// Original SLATEC routine `DLBETA`.
/// Computes the double-precision natural logarithm of the complete Beta function.
/// Mathematical operation: ln(Beta(a, b)).
/// Precision and return ABI: `f64` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: both `A` and `B` must be positive.
/// Selected provider: `full-provider-1ee90cb746883a0f`; source: <https://www.netlib.org/slatec/fnlib/dlbeta.f>; native symbol: `dlbeta_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `A`: first input real parameter, passed by address; null is not permitted, the value is read only, and the documented beta-function domain requires it to be positive.
/// - `B`: second input real parameter, passed by address; null is not permitted, the value is read only, and the documented beta-function domain requires it to be positive.
///
/// # Native behavior
/// The selected source reports documented domain, overflow, underflow, or precision conditions through legacy XERROR/XERMSG; a raw caller must avoid fatal configurations and does not receive a Rust error value.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dlbeta.md"))]
pub use crate::families::special_beta::dlbeta;
}
/// Reviewed scalar special-function routines in the `error` group.
#[cfg(any(feature = "special-error", feature = "raw-family-special-error"))]
pub mod error {
// raw-api-routine: DERF
/// Original SLATEC routine `DERF`.
/// Computes the double-precision error function.
/// Mathematical operation: 2/sqrt(pi) times the integral of exp(-t²) from zero to x.
/// Precision and return ABI: `f64` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: finite real inputs are supported; ordinary finite inputs do not have a mathematical domain error.
/// Selected provider: `full-provider-3b43b57f60c467f6`; source: <https://www.netlib.org/slatec/fnlib/derf.f>; native symbol: `derf_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, the value is read only, and it must satisfy the routine's documented domain.
///
/// # Native behavior
/// The source initializes saved coefficients; its complementary-function path handles tail underflow according to the native floating-point behavior.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/derf.md"))]
pub use crate::families::special_error::derf;
// raw-api-routine: DERFC
/// Original SLATEC routine `DERFC`.
/// Computes the double-precision complementary error function.
/// Mathematical operation: 1 - erf(x).
/// Precision and return ABI: `f64` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: finite real inputs are supported; sufficiently large positive inputs can underflow and report through XERROR.
/// Selected provider: `full-provider-28532b1495f3bac2`; source: <https://www.netlib.org/slatec/fnlib/derfc.f>; native symbol: `derfc_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, the value is read only, and it must satisfy the routine's documented domain.
///
/// # Native behavior
/// The selected source reports documented domain, overflow, underflow, or precision conditions through legacy XERROR/XERMSG; a raw caller must avoid fatal configurations and does not receive a Rust error value.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/derfc.md"))]
pub use crate::families::special_error::derfc;
// raw-api-routine: ERF
/// Original SLATEC routine `ERF`.
/// Computes the error function.
/// Mathematical operation: 2/sqrt(pi) times the integral of exp(-t²) from zero to x.
/// Precision and return ABI: `f32` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: finite real inputs are supported; ordinary finite inputs do not have a mathematical domain error.
/// Selected provider: `full-provider-c05a5f4e5d168e9c`; source: <https://www.netlib.org/slatec/fnlib/erf.f>; native symbol: `erf_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, the value is read only, and it must satisfy the routine's documented domain.
///
/// # Native behavior
/// The source initializes saved coefficients; its complementary-function path handles tail underflow according to the native floating-point behavior.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/erf.md"))]
pub use crate::families::special_error::erf;
// raw-api-routine: ERFC
/// Original SLATEC routine `ERFC`.
/// Computes the complementary error function.
/// Mathematical operation: 1 - erf(x).
/// Precision and return ABI: `f32` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: finite real inputs are supported; sufficiently large positive inputs can underflow and report through XERROR.
/// Selected provider: `full-provider-580e6562bfdb75d0`; source: <https://www.netlib.org/slatec/fnlib/erfc.f>; native symbol: `erfc_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; every Fortran scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, the value is read only, and it must satisfy the routine's documented domain.
///
/// # Native behavior
/// The selected source reports documented domain, overflow, underflow, or precision conditions through legacy XERROR/XERMSG; a raw caller must avoid fatal configurations and does not receive a Rust error value.
/// FNLIB may initialize saved coefficients and machine constants on first use; it is not documented as thread-safe by this raw interface.
///
/// # Safety
/// Every argument pointer must be non-null, correctly aligned, and readable as its documented scalar type for the complete call; no pointer is retained and these functions have no output pointer. The caller must link a provider built for the documented GNU MinGW ABI and must not allow a panic or other unwinding to cross this FFI boundary. Stay inside the documented native domain and avoid inputs that can trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error controls are process-global; this raw declaration does not serialize calls, so callers must provide required process-wide synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/erfc.md"))]
pub use crate::families::special_error::erfc;
}
/// Reviewed real scalar Airy-function declarations.
///
/// The complex Amos Airy interfaces and Airy implementation subsidiaries are
/// intentionally not re-exported here; see the generated Airy family report.
#[cfg(any(feature = "special-airy", feature = "raw-family-special-airy"))]
pub mod airy {
// raw-api-routine: AI
/// Original SLATEC routine `AI`.
/// Evaluates the Airy function Ai.
/// Mathematical operation: the real Airy Ai function.
/// Precision and return ABI: `f32` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: real X is accepted; large positive X reaches the documented underflow path.
/// Selected provider: `full-provider-c70e2a1f4c42951f`; source: <https://www.netlib.org/slatec/fnlib/ai.f>; native symbol: `ai_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; the real scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, it is read only for the complete call, aliases no output because there is no output pointer, and the native routine does not retain it.
///
/// # Native behavior
/// For sufficiently large positive X the unscaled Ai implementation returns zero and reports the documented underflow through XERMSG.
/// FNLIB initializes saved coefficients and machine constants on first use; this raw interface does not claim that initialization or the legacy error runtime is thread-safe.
///
/// # Safety
/// `X` must be non-null, correctly aligned, and readable as the documented scalar type for the complete call. The pointer is input-only and is not retained. The caller must link a provider built for the documented GNU MinGW ABI, must not permit a panic or other unwinding across this FFI boundary, and must avoid input ranges that trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error handling are process-global; this raw declaration does not serialize calls, so callers must provide any required synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/ai.md"))]
pub use crate::families::special_airy::ai;
// raw-api-routine: AIE
/// Original SLATEC routine `AIE`.
/// Evaluates Ai, exponentially scaled on the non-negative real axis.
/// Mathematical operation: Ai(X) for X <= 0 and exp(2 X^(3/2) / 3) Ai(X) for X >= 0.
/// Precision and return ABI: `f32` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: real X is accepted.
/// Selected provider: `full-provider-d879e285d4a9dea9`; source: <https://www.netlib.org/slatec/fnlib/aie.f>; native symbol: `aie_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; the real scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, it is read only for the complete call, aliases no output because there is no output pointer, and the native routine does not retain it.
///
/// # Native behavior
/// The scaled implementation avoids the corresponding positive-real exponential range problem; its finite-input result and any machine-limit behavior remain those of the selected FNLIB source.
/// FNLIB initializes saved coefficients and machine constants on first use; this raw interface does not claim that initialization or the legacy error runtime is thread-safe.
///
/// # Safety
/// `X` must be non-null, correctly aligned, and readable as the documented scalar type for the complete call. The pointer is input-only and is not retained. The caller must link a provider built for the documented GNU MinGW ABI, must not permit a panic or other unwinding across this FFI boundary, and must avoid input ranges that trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error handling are process-global; this raw declaration does not serialize calls, so callers must provide any required synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/aie.md"))]
pub use crate::families::special_airy::aie;
// raw-api-routine: BI
/// Original SLATEC routine `BI`.
/// Evaluates the Bairy function Bi, the Airy function of the second kind.
/// Mathematical operation: the real Airy Bi function.
/// Precision and return ABI: `f32` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: real X is accepted; large positive X reaches the documented overflow path.
/// Selected provider: `full-provider-69fc1b8a6fdbbe85`; source: <https://www.netlib.org/slatec/fnlib/bi.f>; native symbol: `bi_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; the real scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, it is read only for the complete call, aliases no output because there is no output pointer, and the native routine does not retain it.
///
/// # Native behavior
/// For sufficiently large positive X the unscaled Bi implementation reports its documented overflow through XERMSG.
/// FNLIB initializes saved coefficients and machine constants on first use; this raw interface does not claim that initialization or the legacy error runtime is thread-safe.
///
/// # Safety
/// `X` must be non-null, correctly aligned, and readable as the documented scalar type for the complete call. The pointer is input-only and is not retained. The caller must link a provider built for the documented GNU MinGW ABI, must not permit a panic or other unwinding across this FFI boundary, and must avoid input ranges that trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error handling are process-global; this raw declaration does not serialize calls, so callers must provide any required synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/bi.md"))]
pub use crate::families::special_airy::bi;
// raw-api-routine: BIE
/// Original SLATEC routine `BIE`.
/// Evaluates Bi, exponentially scaled on the non-negative real axis.
/// Mathematical operation: Bi(X) for X <= 0 and exp(-2 X^(3/2) / 3) Bi(X) for X >= 0.
/// Precision and return ABI: `f32` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: real X is accepted.
/// Selected provider: `full-provider-207c5e6b0575db12`; source: <https://www.netlib.org/slatec/fnlib/bie.f>; native symbol: `bie_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; the real scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, it is read only for the complete call, aliases no output because there is no output pointer, and the native routine does not retain it.
///
/// # Native behavior
/// The scaled implementation avoids the corresponding positive-real exponential range problem; its finite-input result and any machine-limit behavior remain those of the selected FNLIB source.
/// FNLIB initializes saved coefficients and machine constants on first use; this raw interface does not claim that initialization or the legacy error runtime is thread-safe.
///
/// # Safety
/// `X` must be non-null, correctly aligned, and readable as the documented scalar type for the complete call. The pointer is input-only and is not retained. The caller must link a provider built for the documented GNU MinGW ABI, must not permit a panic or other unwinding across this FFI boundary, and must avoid input ranges that trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error handling are process-global; this raw declaration does not serialize calls, so callers must provide any required synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/bie.md"))]
pub use crate::families::special_airy::bie;
// raw-api-routine: DAI
/// Original SLATEC routine `DAI`.
/// Evaluates the double-precision Airy function Ai.
/// Mathematical operation: the real double-precision Airy Ai function.
/// Precision and return ABI: `f64` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: real X is accepted; large positive X reaches the documented underflow path.
/// Selected provider: `full-provider-ae0fc8344c988f89`; source: <https://www.netlib.org/slatec/fnlib/dai.f>; native symbol: `dai_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; the real scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, it is read only for the complete call, aliases no output because there is no output pointer, and the native routine does not retain it.
///
/// # Native behavior
/// For sufficiently large positive X the unscaled Ai implementation returns zero and reports the documented underflow through XERMSG.
/// FNLIB initializes saved coefficients and machine constants on first use; this raw interface does not claim that initialization or the legacy error runtime is thread-safe.
///
/// # Safety
/// `X` must be non-null, correctly aligned, and readable as the documented scalar type for the complete call. The pointer is input-only and is not retained. The caller must link a provider built for the documented GNU MinGW ABI, must not permit a panic or other unwinding across this FFI boundary, and must avoid input ranges that trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error handling are process-global; this raw declaration does not serialize calls, so callers must provide any required synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dai.md"))]
pub use crate::families::special_airy::dai;
// raw-api-routine: DAIE
/// Original SLATEC routine `DAIE`.
/// Evaluates double-precision Ai, exponentially scaled on the non-negative real axis.
/// Mathematical operation: Ai(X) for X <= 0 and exp(2 X^(3/2) / 3) Ai(X) for X >= 0.
/// Precision and return ABI: `f64` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: real X is accepted.
/// Selected provider: `full-provider-c599169a8f7e8e11`; source: <https://www.netlib.org/slatec/fnlib/daie.f>; native symbol: `daie_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; the real scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, it is read only for the complete call, aliases no output because there is no output pointer, and the native routine does not retain it.
///
/// # Native behavior
/// The scaled implementation avoids the corresponding positive-real exponential range problem; its finite-input result and any machine-limit behavior remain those of the selected FNLIB source.
/// FNLIB initializes saved coefficients and machine constants on first use; this raw interface does not claim that initialization or the legacy error runtime is thread-safe.
///
/// # Safety
/// `X` must be non-null, correctly aligned, and readable as the documented scalar type for the complete call. The pointer is input-only and is not retained. The caller must link a provider built for the documented GNU MinGW ABI, must not permit a panic or other unwinding across this FFI boundary, and must avoid input ranges that trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error handling are process-global; this raw declaration does not serialize calls, so callers must provide any required synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/daie.md"))]
pub use crate::families::special_airy::daie;
// raw-api-routine: DBI
/// Original SLATEC routine `DBI`.
/// Evaluates the double-precision Bairy function Bi.
/// Mathematical operation: the real double-precision Airy Bi function.
/// Precision and return ABI: `f64` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: real X is accepted; large positive X reaches the documented overflow path.
/// Selected provider: `full-provider-15a5a34d05239dcc`; source: <https://www.netlib.org/slatec/fnlib/dbi.f>; native symbol: `dbi_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; the real scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, it is read only for the complete call, aliases no output because there is no output pointer, and the native routine does not retain it.
///
/// # Native behavior
/// For sufficiently large positive X the unscaled Bi implementation reports its documented overflow through XERMSG.
/// FNLIB initializes saved coefficients and machine constants on first use; this raw interface does not claim that initialization or the legacy error runtime is thread-safe.
///
/// # Safety
/// `X` must be non-null, correctly aligned, and readable as the documented scalar type for the complete call. The pointer is input-only and is not retained. The caller must link a provider built for the documented GNU MinGW ABI, must not permit a panic or other unwinding across this FFI boundary, and must avoid input ranges that trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error handling are process-global; this raw declaration does not serialize calls, so callers must provide any required synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dbi.md"))]
pub use crate::families::special_airy::dbi;
// raw-api-routine: DBIE
/// Original SLATEC routine `DBIE`.
/// Evaluates double-precision Bi, exponentially scaled on the non-negative real axis.
/// Mathematical operation: Bi(X) for X <= 0 and exp(-2 X^(3/2) / 3) Bi(X) for X >= 0.
/// Precision and return ABI: `f64` Fortran scalar function returned directly by the supported GNU MinGW ABI.
/// Domain and exceptional behavior: real X is accepted.
/// Selected provider: `full-provider-3b7c3a2e59d914d7`; source: <https://www.netlib.org/slatec/fnlib/dbie.f>; native symbol: `dbie_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64`; the real scalar input is passed by address.
///
/// # Arguments
/// - `X`: input real scalar, passed by address; null is not permitted, it is read only for the complete call, aliases no output because there is no output pointer, and the native routine does not retain it.
///
/// # Native behavior
/// The scaled implementation avoids the corresponding positive-real exponential range problem; its finite-input result and any machine-limit behavior remain those of the selected FNLIB source.
/// FNLIB initializes saved coefficients and machine constants on first use; this raw interface does not claim that initialization or the legacy error runtime is thread-safe.
///
/// # Safety
/// `X` must be non-null, correctly aligned, and readable as the documented scalar type for the complete call. The pointer is input-only and is not retained. The caller must link a provider built for the documented GNU MinGW ABI, must not permit a panic or other unwinding across this FFI boundary, and must avoid input ranges that trigger fatal legacy XERROR behavior. FNLIB initialization and legacy error handling are process-global; this raw declaration does not serialize calls, so callers must provide any required synchronization.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dbie.md"))]
pub use crate::families::special_airy::dbie;
}
#[cfg(feature = "raw-family-special-real")]
#[path = "batch_a/special.rs"]
mod canonical_bindings;
/// Canonical source-verified real special-function declarations.
#[cfg(feature = "raw-family-special-real")]
pub use canonical_bindings::*;
/// Complex-valued special-function interfaces.
#[cfg(feature = "raw-family-special-complex")]
pub mod complex {
pub use crate::abi_bindings::special::*;
}