//! Generated canonical ABI-sensitive raw bindings.
//!
//! These declarations are organized by mathematical family. Do not edit this file directly.
// raw-api-routine: C0LGMC
unsafe extern "C" {
/// Evaluate (Z+0.5)*LOG((Z+1.)/Z) - 1.0 with relative accuracy.
///
/// Original SLATEC routine `C0LGMC`; source: <https://www.netlib.org/slatec/fnlib/c0lgmc.f>; source SHA-256: `d3a1d283ebb66b6ec0a062f53e8d6530555d4973c2ca2c6cacfa17d6357aeb04`; native symbol: `c0lgmc_`.
/// Supported ABI: GNU MinGW `x86_64-pc-windows-gnu`; ABI class `complex_return`; fingerprint `function:complex32(mut_complex32)`.
/// Complex values use `crate::Complex32` or `crate::Complex64` in real/imaginary order. Complex arguments are passed by pointer; complex function results use the compiler-probed direct aggregate-return convention.
///
/// # Arguments
///
/// - `Z`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - Return: compiler-validated Fortran `COMPLEX` value.
///
/// # Safety
///
/// This declaration is source/hash, symbol, ABI-profile, compile, and bulk-link validated; it is not a safe or universally numerically validated API. Every pointer must be non-null, aligned, and valid for every native access; array storage, strides, leading dimensions, workspace, and aliasing must satisfy the selected source prologue. Rust callbacks, if present, must use the exact compiler-validated callback ABI and must not unwind. The native routine retains no pointer. Callers must link the documented GNU MinGW-compatible provider and serialize any process-global SLATEC state.
#[link_name = "c0lgmc_"]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/c0lgmc.md"))]
pub fn c0lgmc(z: *mut crate::Complex32) -> crate::Complex32;
}
// raw-api-routine: CACOS
unsafe extern "C" {
/// Compute the complex arc cosine.
///
/// Original SLATEC routine `CACOS`; source: <https://www.netlib.org/slatec/fnlib/cacos.f>; source SHA-256: `fbd1baf1e982053b5dd6191a82527a251bf28629bc5b62d7f345b300968b8118`; native symbol: `cacos_`.
/// Supported ABI: GNU MinGW `x86_64-pc-windows-gnu`; ABI class `complex_return`; fingerprint `function:complex32(mut_complex32)`.
/// Complex values use `crate::Complex32` or `crate::Complex64` in real/imaginary order. Complex arguments are passed by pointer; complex function results use the compiler-probed direct aggregate-return convention.
///
/// # Arguments
///
/// - `Z`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - Return: compiler-validated Fortran `COMPLEX` value.
///
/// # Safety
///
/// This declaration is source/hash, symbol, ABI-profile, compile, and bulk-link validated; it is not a safe or universally numerically validated API. Every pointer must be non-null, aligned, and valid for every native access; array storage, strides, leading dimensions, workspace, and aliasing must satisfy the selected source prologue. Rust callbacks, if present, must use the exact compiler-validated callback ABI and must not unwind. The native routine retains no pointer. Callers must link the documented GNU MinGW-compatible provider and serialize any process-global SLATEC state.
#[link_name = "cacos_"]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/cacos.md"))]
pub fn cacos(z: *mut crate::Complex32) -> crate::Complex32;
}
// raw-api-routine: CACOSH
unsafe extern "C" {
/// Compute the arc hyperbolic cosine.
///
/// Original SLATEC routine `CACOSH`; source: <https://www.netlib.org/slatec/fnlib/cacosh.f>; source SHA-256: `9190ecb63bd2cb87ad7fdfc4d44ff39b82564a18f88fdc3f60921c71515afa48`; native symbol: `cacosh_`.
/// Supported ABI: GNU MinGW `x86_64-pc-windows-gnu`; ABI class `complex_return`; fingerprint `function:complex32(mut_complex32)`.
/// Complex values use `crate::Complex32` or `crate::Complex64` in real/imaginary order. Complex arguments are passed by pointer; complex function results use the compiler-probed direct aggregate-return convention.
///
/// # Arguments
///
/// - `Z`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - Return: compiler-validated Fortran `COMPLEX` value.
///
/// # Safety
///
/// This declaration is source/hash, symbol, ABI-profile, compile, and bulk-link validated; it is not a safe or universally numerically validated API. Every pointer must be non-null, aligned, and valid for every native access; array storage, strides, leading dimensions, workspace, and aliasing must satisfy the selected source prologue. Rust callbacks, if present, must use the exact compiler-validated callback ABI and must not unwind. The native routine retains no pointer. Callers must link the documented GNU MinGW-compatible provider and serialize any process-global SLATEC state.
#[link_name = "cacosh_"]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/cacosh.md"))]
pub fn cacosh(z: *mut crate::Complex32) -> crate::Complex32;
}
// raw-api-routine: CAIRY
unsafe extern "C" {
/// Compute the Airy function Ai(z) or its derivative dAi/dz for complex argument z. A scaling option is available to help avoid underflow and overflow.
///
/// Original SLATEC routine `CAIRY`; source: <https://www.netlib.org/slatec/src/cairy.f>; source SHA-256: `3af7629acad3d563fcb417444824744ecce5d37b9b318225439abb9f9220c007`; native symbol: `cairy_`.
/// Supported ABI: GNU MinGW `x86_64-pc-windows-gnu`; ABI class `complex_argument_or_output`; fingerprint `subroutine:void(mut_complex32,mut_i32,mut_i32,mut_complex32,mut_i32,mut_i32)`.
/// Complex values use `crate::Complex32` or `crate::Complex64` in real/imaginary order. Complex arguments are passed by pointer; complex function results use the compiler-probed direct aggregate-return convention.
///
/// # Arguments
///
/// - `Z`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `ID`: Fortran `INTEGER` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `KODE`: Fortran `INTEGER` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `AI`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `NZ`: Fortran `INTEGER` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `IERR`: Fortran `INTEGER` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
///
/// # Safety
///
/// This declaration is source/hash, symbol, ABI-profile, compile, and bulk-link validated; it is not a safe or universally numerically validated API. Every pointer must be non-null, aligned, and valid for every native access; array storage, strides, leading dimensions, workspace, and aliasing must satisfy the selected source prologue. Rust callbacks, if present, must use the exact compiler-validated callback ABI and must not unwind. The native routine retains no pointer. Callers must link the documented GNU MinGW-compatible provider and serialize any process-global SLATEC state.
#[link_name = "cairy_"]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/cairy.md"))]
pub fn cairy(
z: *mut crate::Complex32,
id: *mut crate::FortranInteger,
kode: *mut crate::FortranInteger,
ai: *mut crate::Complex32,
nz: *mut crate::FortranInteger,
ierr: *mut crate::FortranInteger,
);
}
// raw-api-routine: CASIN
unsafe extern "C" {
/// Compute the complex arc sine.
///
/// Original SLATEC routine `CASIN`; source: <https://www.netlib.org/slatec/fnlib/casin.f>; source SHA-256: `a9e028358576f1af816ee55ee106fc8c2e64743c8b7dc166469f223de6798530`; native symbol: `casin_`.
/// Supported ABI: GNU MinGW `x86_64-pc-windows-gnu`; ABI class `complex_return`; fingerprint `function:complex32(mut_complex32)`.
/// Complex values use `crate::Complex32` or `crate::Complex64` in real/imaginary order. Complex arguments are passed by pointer; complex function results use the compiler-probed direct aggregate-return convention.
///
/// # Arguments
///
/// - `ZINP`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - Return: compiler-validated Fortran `COMPLEX` value.
///
/// # Safety
///
/// This declaration is source/hash, symbol, ABI-profile, compile, and bulk-link validated; it is not a safe or universally numerically validated API. Every pointer must be non-null, aligned, and valid for every native access; array storage, strides, leading dimensions, workspace, and aliasing must satisfy the selected source prologue. Rust callbacks, if present, must use the exact compiler-validated callback ABI and must not unwind. The native routine retains no pointer. Callers must link the documented GNU MinGW-compatible provider and serialize any process-global SLATEC state.
#[link_name = "casin_"]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/casin.md"))]
pub fn casin(zinp: *mut crate::Complex32) -> crate::Complex32;
}
// raw-api-routine: CASINH
unsafe extern "C" {
/// Compute the arc hyperbolic sine.
///
/// Original SLATEC routine `CASINH`; source: <https://www.netlib.org/slatec/fnlib/casinh.f>; source SHA-256: `dcb026e214e1653f0f02fc66eec199ea9bec2e951228cd5d305c47d9c5edc86f`; native symbol: `casinh_`.
/// Supported ABI: GNU MinGW `x86_64-pc-windows-gnu`; ABI class `complex_return`; fingerprint `function:complex32(mut_complex32)`.
/// Complex values use `crate::Complex32` or `crate::Complex64` in real/imaginary order. Complex arguments are passed by pointer; complex function results use the compiler-probed direct aggregate-return convention.
///
/// # Arguments
///
/// - `Z`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - Return: compiler-validated Fortran `COMPLEX` value.
///
/// # Safety
///
/// This declaration is source/hash, symbol, ABI-profile, compile, and bulk-link validated; it is not a safe or universally numerically validated API. Every pointer must be non-null, aligned, and valid for every native access; array storage, strides, leading dimensions, workspace, and aliasing must satisfy the selected source prologue. Rust callbacks, if present, must use the exact compiler-validated callback ABI and must not unwind. The native routine retains no pointer. Callers must link the documented GNU MinGW-compatible provider and serialize any process-global SLATEC state.
#[link_name = "casinh_"]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/casinh.md"))]
pub fn casinh(z: *mut crate::Complex32) -> crate::Complex32;
}
// raw-api-routine: CATAN
unsafe extern "C" {
/// Compute the complex arc tangent.
///
/// Original SLATEC routine `CATAN`; source: <https://www.netlib.org/slatec/fnlib/catan.f>; source SHA-256: `645340b5af7f4d5b6255944234c6ec187d74c7f4a39b9e16b15e101f1f4624d7`; native symbol: `catan_`.
/// Supported ABI: GNU MinGW `x86_64-pc-windows-gnu`; ABI class `complex_return`; fingerprint `function:complex32(mut_complex32)`.
/// Complex values use `crate::Complex32` or `crate::Complex64` in real/imaginary order. Complex arguments are passed by pointer; complex function results use the compiler-probed direct aggregate-return convention.
///
/// # Arguments
///
/// - `Z`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - Return: compiler-validated Fortran `COMPLEX` value.
///
/// # Safety
///
/// This declaration is source/hash, symbol, ABI-profile, compile, and bulk-link validated; it is not a safe or universally numerically validated API. Every pointer must be non-null, aligned, and valid for every native access; array storage, strides, leading dimensions, workspace, and aliasing must satisfy the selected source prologue. Rust callbacks, if present, must use the exact compiler-validated callback ABI and must not unwind. The native routine retains no pointer. Callers must link the documented GNU MinGW-compatible provider and serialize any process-global SLATEC state.
#[link_name = "catan_"]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/catan.md"))]
pub fn catan(z: *mut crate::Complex32) -> crate::Complex32;
}
// raw-api-routine: CATAN2
unsafe extern "C" {
/// Compute the complex arc tangent in the proper quadrant.
///
/// Original SLATEC routine `CATAN2`; source: <https://www.netlib.org/slatec/fnlib/catan2.f>; source SHA-256: `85f82bbd001f14b65f814ac4f22f45d2f2179ee4d327562520cf54bf3faacc59`; native symbol: `catan2_`.
/// Supported ABI: GNU MinGW `x86_64-pc-windows-gnu`; ABI class `complex_return`; fingerprint `function:complex32(mut_complex32,mut_complex32)`.
/// Complex values use `crate::Complex32` or `crate::Complex64` in real/imaginary order. Complex arguments are passed by pointer; complex function results use the compiler-probed direct aggregate-return convention.
///
/// # Arguments
///
/// - `CSN`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `CCS`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - Return: compiler-validated Fortran `COMPLEX` value.
///
/// # Safety
///
/// This declaration is source/hash, symbol, ABI-profile, compile, and bulk-link validated; it is not a safe or universally numerically validated API. Every pointer must be non-null, aligned, and valid for every native access; array storage, strides, leading dimensions, workspace, and aliasing must satisfy the selected source prologue. Rust callbacks, if present, must use the exact compiler-validated callback ABI and must not unwind. The native routine retains no pointer. Callers must link the documented GNU MinGW-compatible provider and serialize any process-global SLATEC state.
#[link_name = "catan2_"]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/catan2.md"))]
pub fn catan2(csn: *mut crate::Complex32, ccs: *mut crate::Complex32) -> crate::Complex32;
}
// raw-api-routine: CATANH
unsafe extern "C" {
/// Compute the arc hyperbolic tangent.
///
/// Original SLATEC routine `CATANH`; source: <https://www.netlib.org/slatec/fnlib/catanh.f>; source SHA-256: `612077084a1b2f474801b9c9302c6af6e0164e1689ea350ed6c8b6c4c9ad8d28`; native symbol: `catanh_`.
/// Supported ABI: GNU MinGW `x86_64-pc-windows-gnu`; ABI class `complex_return`; fingerprint `function:complex32(mut_complex32)`.
/// Complex values use `crate::Complex32` or `crate::Complex64` in real/imaginary order. Complex arguments are passed by pointer; complex function results use the compiler-probed direct aggregate-return convention.
///
/// # Arguments
///
/// - `Z`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - Return: compiler-validated Fortran `COMPLEX` value.
///
/// # Safety
///
/// This declaration is source/hash, symbol, ABI-profile, compile, and bulk-link validated; it is not a safe or universally numerically validated API. Every pointer must be non-null, aligned, and valid for every native access; array storage, strides, leading dimensions, workspace, and aliasing must satisfy the selected source prologue. Rust callbacks, if present, must use the exact compiler-validated callback ABI and must not unwind. The native routine retains no pointer. Callers must link the documented GNU MinGW-compatible provider and serialize any process-global SLATEC state.
#[link_name = "catanh_"]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/catanh.md"))]
pub fn catanh(z: *mut crate::Complex32) -> crate::Complex32;
}
// raw-api-routine: CBESH
unsafe extern "C" {
/// Compute a sequence of the Hankel functions H(m,a,z) for superscript m=1 or 2, real nonnegative orders a=b, b+1,... where b>0, and nonzero complex argument z. A scaling option is available to help avoid overflow.
///
/// Original SLATEC routine `CBESH`; source: <https://www.netlib.org/slatec/src/cbesh.f>; source SHA-256: `10531064ead43b4bc92030601232861a7bfb656956432ea85ca3001c81535cd1`; native symbol: `cbesh_`.
/// Supported ABI: GNU MinGW `x86_64-pc-windows-gnu`; ABI class `complex_argument_or_output`; fingerprint `subroutine:void(mut_complex32,mut_f32,mut_i32,mut_i32,mut_i32,mut_complex32_array_rank1,mut_i32,mut_i32)`.
/// Complex values use `crate::Complex32` or `crate::Complex64` in real/imaginary order. Complex arguments are passed by pointer; complex function results use the compiler-probed direct aggregate-return convention.
///
/// # Arguments
///
/// - `Z`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `FNU`: Fortran `REAL` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `KODE`: Fortran `INTEGER` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `M`: Fortran `INTEGER` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `N`: Fortran `INTEGER` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `CY`: Fortran `COMPLEX` rank-1 array. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `NZ`: Fortran `INTEGER` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `IERR`: Fortran `INTEGER` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
///
/// # Safety
///
/// This declaration is source/hash, symbol, ABI-profile, compile, and bulk-link validated; it is not a safe or universally numerically validated API. Every pointer must be non-null, aligned, and valid for every native access; array storage, strides, leading dimensions, workspace, and aliasing must satisfy the selected source prologue. Rust callbacks, if present, must use the exact compiler-validated callback ABI and must not unwind. The native routine retains no pointer. Callers must link the documented GNU MinGW-compatible provider and serialize any process-global SLATEC state.
#[link_name = "cbesh_"]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/cbesh.md"))]
pub fn cbesh(
z: *mut crate::Complex32,
fnu: *mut f32,
kode: *mut crate::FortranInteger,
m: *mut crate::FortranInteger,
n: *mut crate::FortranInteger,
cy: *mut crate::Complex32,
nz: *mut crate::FortranInteger,
ierr: *mut crate::FortranInteger,
);
}
// raw-api-routine: CBESI
unsafe extern "C" {
/// Compute a sequence of the Bessel functions I(a,z) for complex argument z and real nonnegative orders a=b,b+1, b+2,... where b>0. A scaling option is available to help avoid overflow.
///
/// Original SLATEC routine `CBESI`; source: <https://www.netlib.org/slatec/src/cbesi.f>; source SHA-256: `e55624becdd69c802dd1e6ab6f81883e357b9e028c2bb0440ffe198ca006f887`; native symbol: `cbesi_`.
/// Supported ABI: GNU MinGW `x86_64-pc-windows-gnu`; ABI class `complex_argument_or_output`; fingerprint `subroutine:void(mut_complex32,mut_f32,mut_i32,mut_i32,mut_complex32_array_rank1,mut_i32,mut_i32)`.
/// Complex values use `crate::Complex32` or `crate::Complex64` in real/imaginary order. Complex arguments are passed by pointer; complex function results use the compiler-probed direct aggregate-return convention.
///
/// # Arguments
///
/// - `Z`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `FNU`: Fortran `REAL` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `KODE`: Fortran `INTEGER` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `N`: Fortran `INTEGER` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `CY`: Fortran `COMPLEX` rank-1 array. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `NZ`: Fortran `INTEGER` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `IERR`: Fortran `INTEGER` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
///
/// # Safety
///
/// This declaration is source/hash, symbol, ABI-profile, compile, and bulk-link validated; it is not a safe or universally numerically validated API. Every pointer must be non-null, aligned, and valid for every native access; array storage, strides, leading dimensions, workspace, and aliasing must satisfy the selected source prologue. Rust callbacks, if present, must use the exact compiler-validated callback ABI and must not unwind. The native routine retains no pointer. Callers must link the documented GNU MinGW-compatible provider and serialize any process-global SLATEC state.
#[link_name = "cbesi_"]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/cbesi.md"))]
pub fn cbesi(
z: *mut crate::Complex32,
fnu: *mut f32,
kode: *mut crate::FortranInteger,
n: *mut crate::FortranInteger,
cy: *mut crate::Complex32,
nz: *mut crate::FortranInteger,
ierr: *mut crate::FortranInteger,
);
}
// raw-api-routine: CBESJ
unsafe extern "C" {
/// Compute a sequence of the Bessel functions J(a,z) for complex argument z and real nonnegative orders a=b,b+1, b+2,... where b>0. A scaling option is available to help avoid overflow.
///
/// Original SLATEC routine `CBESJ`; source: <https://www.netlib.org/slatec/src/cbesj.f>; source SHA-256: `703650d99d0cd218417c9df8f1f1354fa553e65bdd77b6fa8346b22a9e000968`; native symbol: `cbesj_`.
/// Supported ABI: GNU MinGW `x86_64-pc-windows-gnu`; ABI class `complex_argument_or_output`; fingerprint `subroutine:void(mut_complex32,mut_f32,mut_i32,mut_i32,mut_complex32_array_rank1,mut_i32,mut_i32)`.
/// Complex values use `crate::Complex32` or `crate::Complex64` in real/imaginary order. Complex arguments are passed by pointer; complex function results use the compiler-probed direct aggregate-return convention.
///
/// # Arguments
///
/// - `Z`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `FNU`: Fortran `REAL` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `KODE`: Fortran `INTEGER` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `N`: Fortran `INTEGER` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `CY`: Fortran `COMPLEX` rank-1 array. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `NZ`: Fortran `INTEGER` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `IERR`: Fortran `INTEGER` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
///
/// # Safety
///
/// This declaration is source/hash, symbol, ABI-profile, compile, and bulk-link validated; it is not a safe or universally numerically validated API. Every pointer must be non-null, aligned, and valid for every native access; array storage, strides, leading dimensions, workspace, and aliasing must satisfy the selected source prologue. Rust callbacks, if present, must use the exact compiler-validated callback ABI and must not unwind. The native routine retains no pointer. Callers must link the documented GNU MinGW-compatible provider and serialize any process-global SLATEC state.
#[link_name = "cbesj_"]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/cbesj.md"))]
pub fn cbesj(
z: *mut crate::Complex32,
fnu: *mut f32,
kode: *mut crate::FortranInteger,
n: *mut crate::FortranInteger,
cy: *mut crate::Complex32,
nz: *mut crate::FortranInteger,
ierr: *mut crate::FortranInteger,
);
}
// raw-api-routine: CBESK
unsafe extern "C" {
/// Compute a sequence of the Bessel functions K(a,z) for complex argument z and real nonnegative orders a=b,b+1, b+2,... where b>0. A scaling option is available to help avoid overflow.
///
/// Original SLATEC routine `CBESK`; source: <https://www.netlib.org/slatec/src/cbesk.f>; source SHA-256: `7a5ee76b933a97e54c1ce25377ea65580ec4f721103bc0e28e193480bd493bbe`; native symbol: `cbesk_`.
/// Supported ABI: GNU MinGW `x86_64-pc-windows-gnu`; ABI class `complex_argument_or_output`; fingerprint `subroutine:void(mut_complex32,mut_f32,mut_i32,mut_i32,mut_complex32_array_rank1,mut_i32,mut_i32)`.
/// Complex values use `crate::Complex32` or `crate::Complex64` in real/imaginary order. Complex arguments are passed by pointer; complex function results use the compiler-probed direct aggregate-return convention.
///
/// # Arguments
///
/// - `Z`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `FNU`: Fortran `REAL` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `KODE`: Fortran `INTEGER` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `N`: Fortran `INTEGER` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `CY`: Fortran `COMPLEX` rank-1 array. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `NZ`: Fortran `INTEGER` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `IERR`: Fortran `INTEGER` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
///
/// # Safety
///
/// This declaration is source/hash, symbol, ABI-profile, compile, and bulk-link validated; it is not a safe or universally numerically validated API. Every pointer must be non-null, aligned, and valid for every native access; array storage, strides, leading dimensions, workspace, and aliasing must satisfy the selected source prologue. Rust callbacks, if present, must use the exact compiler-validated callback ABI and must not unwind. The native routine retains no pointer. Callers must link the documented GNU MinGW-compatible provider and serialize any process-global SLATEC state.
#[link_name = "cbesk_"]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/cbesk.md"))]
pub fn cbesk(
z: *mut crate::Complex32,
fnu: *mut f32,
kode: *mut crate::FortranInteger,
n: *mut crate::FortranInteger,
cy: *mut crate::Complex32,
nz: *mut crate::FortranInteger,
ierr: *mut crate::FortranInteger,
);
}
// raw-api-routine: CBESY
unsafe extern "C" {
/// Compute a sequence of the Bessel functions Y(a,z) for complex argument z and real nonnegative orders a=b,b+1, b+2,... where b>0. A scaling option is available to help avoid overflow.
///
/// Original SLATEC routine `CBESY`; source: <https://www.netlib.org/slatec/src/cbesy.f>; source SHA-256: `6907d6ca8897a72f129e604a89759f5b4a150add4df4ffe8945643adf7e7392f`; native symbol: `cbesy_`.
/// Supported ABI: GNU MinGW `x86_64-pc-windows-gnu`; ABI class `complex_argument_or_output`; fingerprint `subroutine:void(mut_complex32,mut_f32,mut_i32,mut_i32,mut_complex32_array_rank1,mut_i32,mut_complex32_array_rank1,mut_i32)`.
/// Complex values use `crate::Complex32` or `crate::Complex64` in real/imaginary order. Complex arguments are passed by pointer; complex function results use the compiler-probed direct aggregate-return convention.
///
/// # Arguments
///
/// - `Z`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `FNU`: Fortran `REAL` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `KODE`: Fortran `INTEGER` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `N`: Fortran `INTEGER` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `CY`: Fortran `COMPLEX` rank-1 array. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `NZ`: Fortran `INTEGER` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `CWRK`: Fortran `COMPLEX` rank-1 array. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `IERR`: Fortran `INTEGER` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
///
/// # Safety
///
/// This declaration is source/hash, symbol, ABI-profile, compile, and bulk-link validated; it is not a safe or universally numerically validated API. Every pointer must be non-null, aligned, and valid for every native access; array storage, strides, leading dimensions, workspace, and aliasing must satisfy the selected source prologue. Rust callbacks, if present, must use the exact compiler-validated callback ABI and must not unwind. The native routine retains no pointer. Callers must link the documented GNU MinGW-compatible provider and serialize any process-global SLATEC state.
#[link_name = "cbesy_"]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/cbesy.md"))]
pub fn cbesy(
z: *mut crate::Complex32,
fnu: *mut f32,
kode: *mut crate::FortranInteger,
n: *mut crate::FortranInteger,
cy: *mut crate::Complex32,
nz: *mut crate::FortranInteger,
cwrk: *mut crate::Complex32,
ierr: *mut crate::FortranInteger,
);
}
// raw-api-routine: CBETA
unsafe extern "C" {
/// Compute the complete Beta function.
///
/// Original SLATEC routine `CBETA`; source: <https://www.netlib.org/slatec/fnlib/cbeta.f>; source SHA-256: `767a2158da9699beea710c2eed471554782d91e6a2e86c76fe78d7d7db03bfc6`; native symbol: `cbeta_`.
/// Supported ABI: GNU MinGW `x86_64-pc-windows-gnu`; ABI class `complex_return`; fingerprint `function:complex32(mut_complex32,mut_complex32)`.
/// Complex values use `crate::Complex32` or `crate::Complex64` in real/imaginary order. Complex arguments are passed by pointer; complex function results use the compiler-probed direct aggregate-return convention.
///
/// # Arguments
///
/// - `A`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `B`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - Return: compiler-validated Fortran `COMPLEX` value.
///
/// # Safety
///
/// This declaration is source/hash, symbol, ABI-profile, compile, and bulk-link validated; it is not a safe or universally numerically validated API. Every pointer must be non-null, aligned, and valid for every native access; array storage, strides, leading dimensions, workspace, and aliasing must satisfy the selected source prologue. Rust callbacks, if present, must use the exact compiler-validated callback ABI and must not unwind. The native routine retains no pointer. Callers must link the documented GNU MinGW-compatible provider and serialize any process-global SLATEC state.
#[link_name = "cbeta_"]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/cbeta.md"))]
pub fn cbeta(a: *mut crate::Complex32, b: *mut crate::Complex32) -> crate::Complex32;
}
// raw-api-routine: CBIRY
unsafe extern "C" {
/// Compute the Airy function Bi(z) or its derivative dBi/dz for complex argument z. A scaling option is available to help avoid overflow.
///
/// Original SLATEC routine `CBIRY`; source: <https://www.netlib.org/slatec/src/cbiry.f>; source SHA-256: `39ee04d9a0fbab92993a1a6d6bbdff91998bccafaa5ad99ac2b60c8a1c5c188c`; native symbol: `cbiry_`.
/// Supported ABI: GNU MinGW `x86_64-pc-windows-gnu`; ABI class `complex_argument_or_output`; fingerprint `subroutine:void(mut_complex32,mut_i32,mut_i32,mut_complex32,mut_i32)`.
/// Complex values use `crate::Complex32` or `crate::Complex64` in real/imaginary order. Complex arguments are passed by pointer; complex function results use the compiler-probed direct aggregate-return convention.
///
/// # Arguments
///
/// - `Z`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `ID`: Fortran `INTEGER` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `KODE`: Fortran `INTEGER` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `BI`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `IERR`: Fortran `INTEGER` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
///
/// # Safety
///
/// This declaration is source/hash, symbol, ABI-profile, compile, and bulk-link validated; it is not a safe or universally numerically validated API. Every pointer must be non-null, aligned, and valid for every native access; array storage, strides, leading dimensions, workspace, and aliasing must satisfy the selected source prologue. Rust callbacks, if present, must use the exact compiler-validated callback ABI and must not unwind. The native routine retains no pointer. Callers must link the documented GNU MinGW-compatible provider and serialize any process-global SLATEC state.
#[link_name = "cbiry_"]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/cbiry.md"))]
pub fn cbiry(
z: *mut crate::Complex32,
id: *mut crate::FortranInteger,
kode: *mut crate::FortranInteger,
bi: *mut crate::Complex32,
ierr: *mut crate::FortranInteger,
);
}
// raw-api-routine: CCBRT
unsafe extern "C" {
/// Compute the cube root.
///
/// Original SLATEC routine `CCBRT`; source: <https://www.netlib.org/slatec/fnlib/ccbrt.f>; source SHA-256: `4c979607940192ab2e58768d4c9f047e8c12fe2732c8b46d56aadd22721d65fe`; native symbol: `ccbrt_`.
/// Supported ABI: GNU MinGW `x86_64-pc-windows-gnu`; ABI class `complex_return`; fingerprint `function:complex32(mut_complex32)`.
/// Complex values use `crate::Complex32` or `crate::Complex64` in real/imaginary order. Complex arguments are passed by pointer; complex function results use the compiler-probed direct aggregate-return convention.
///
/// # Arguments
///
/// - `Z`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - Return: compiler-validated Fortran `COMPLEX` value.
///
/// # Safety
///
/// This declaration is source/hash, symbol, ABI-profile, compile, and bulk-link validated; it is not a safe or universally numerically validated API. Every pointer must be non-null, aligned, and valid for every native access; array storage, strides, leading dimensions, workspace, and aliasing must satisfy the selected source prologue. Rust callbacks, if present, must use the exact compiler-validated callback ABI and must not unwind. The native routine retains no pointer. Callers must link the documented GNU MinGW-compatible provider and serialize any process-global SLATEC state.
#[link_name = "ccbrt_"]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/ccbrt.md"))]
pub fn ccbrt(z: *mut crate::Complex32) -> crate::Complex32;
}
// raw-api-routine: CCOSH
unsafe extern "C" {
/// Compute the complex hyperbolic cosine.
///
/// Original SLATEC routine `CCOSH`; source: <https://www.netlib.org/slatec/fnlib/ccosh.f>; source SHA-256: `b87b06cf570d552325449063456fa8e91dc995cfdce8fce8eac01dd07abc5ae1`; native symbol: `ccosh_`.
/// Supported ABI: GNU MinGW `x86_64-pc-windows-gnu`; ABI class `complex_return`; fingerprint `function:complex32(mut_complex32)`.
/// Complex values use `crate::Complex32` or `crate::Complex64` in real/imaginary order. Complex arguments are passed by pointer; complex function results use the compiler-probed direct aggregate-return convention.
///
/// # Arguments
///
/// - `Z`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - Return: compiler-validated Fortran `COMPLEX` value.
///
/// # Safety
///
/// This declaration is source/hash, symbol, ABI-profile, compile, and bulk-link validated; it is not a safe or universally numerically validated API. Every pointer must be non-null, aligned, and valid for every native access; array storage, strides, leading dimensions, workspace, and aliasing must satisfy the selected source prologue. Rust callbacks, if present, must use the exact compiler-validated callback ABI and must not unwind. The native routine retains no pointer. Callers must link the documented GNU MinGW-compatible provider and serialize any process-global SLATEC state.
#[link_name = "ccosh_"]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/ccosh.md"))]
pub fn ccosh(z: *mut crate::Complex32) -> crate::Complex32;
}
// raw-api-routine: CCOT
unsafe extern "C" {
/// Compute the cotangent.
///
/// Original SLATEC routine `CCOT`; source: <https://www.netlib.org/slatec/fnlib/ccot.f>; source SHA-256: `680c9efd94f674788b6c8da2efd59ab19224f6e3ac1f12269d63ebfb0f2dab3f`; native symbol: `ccot_`.
/// Supported ABI: GNU MinGW `x86_64-pc-windows-gnu`; ABI class `complex_return`; fingerprint `function:complex32(mut_complex32)`.
/// Complex values use `crate::Complex32` or `crate::Complex64` in real/imaginary order. Complex arguments are passed by pointer; complex function results use the compiler-probed direct aggregate-return convention.
///
/// # Arguments
///
/// - `Z`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - Return: compiler-validated Fortran `COMPLEX` value.
///
/// # Safety
///
/// This declaration is source/hash, symbol, ABI-profile, compile, and bulk-link validated; it is not a safe or universally numerically validated API. Every pointer must be non-null, aligned, and valid for every native access; array storage, strides, leading dimensions, workspace, and aliasing must satisfy the selected source prologue. Rust callbacks, if present, must use the exact compiler-validated callback ABI and must not unwind. The native routine retains no pointer. Callers must link the documented GNU MinGW-compatible provider and serialize any process-global SLATEC state.
#[link_name = "ccot_"]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/ccot.md"))]
pub fn ccot(z: *mut crate::Complex32) -> crate::Complex32;
}
// raw-api-routine: CEXPRL
unsafe extern "C" {
/// Calculate the relative error exponential (EXP(X)-1)/X.
///
/// Original SLATEC routine `CEXPRL`; source: <https://www.netlib.org/slatec/fnlib/cexprl.f>; source SHA-256: `048006bb852faa460e1dc03579f7046ce046919f48291f778b214c40f37fa365`; native symbol: `cexprl_`.
/// Supported ABI: GNU MinGW `x86_64-pc-windows-gnu`; ABI class `complex_return`; fingerprint `function:complex32(mut_complex32)`.
/// Complex values use `crate::Complex32` or `crate::Complex64` in real/imaginary order. Complex arguments are passed by pointer; complex function results use the compiler-probed direct aggregate-return convention.
///
/// # Arguments
///
/// - `Z`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - Return: compiler-validated Fortran `COMPLEX` value.
///
/// # Safety
///
/// This declaration is source/hash, symbol, ABI-profile, compile, and bulk-link validated; it is not a safe or universally numerically validated API. Every pointer must be non-null, aligned, and valid for every native access; array storage, strides, leading dimensions, workspace, and aliasing must satisfy the selected source prologue. Rust callbacks, if present, must use the exact compiler-validated callback ABI and must not unwind. The native routine retains no pointer. Callers must link the documented GNU MinGW-compatible provider and serialize any process-global SLATEC state.
#[link_name = "cexprl_"]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/cexprl.md"))]
pub fn cexprl(z: *mut crate::Complex32) -> crate::Complex32;
}
// raw-api-routine: CGAMMA
unsafe extern "C" {
/// Compute the complete Gamma function.
///
/// Original SLATEC routine `CGAMMA`; source: <https://www.netlib.org/slatec/fnlib/cgamma.f>; source SHA-256: `5f7e6df9ddb2460c0f166198310609ee5de6d88aab0a714cee24cb890e2e936a`; native symbol: `cgamma_`.
/// Supported ABI: GNU MinGW `x86_64-pc-windows-gnu`; ABI class `complex_return`; fingerprint `function:complex32(mut_complex32)`.
/// Complex values use `crate::Complex32` or `crate::Complex64` in real/imaginary order. Complex arguments are passed by pointer; complex function results use the compiler-probed direct aggregate-return convention.
///
/// # Arguments
///
/// - `Z`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - Return: compiler-validated Fortran `COMPLEX` value.
///
/// # Safety
///
/// This declaration is source/hash, symbol, ABI-profile, compile, and bulk-link validated; it is not a safe or universally numerically validated API. Every pointer must be non-null, aligned, and valid for every native access; array storage, strides, leading dimensions, workspace, and aliasing must satisfy the selected source prologue. Rust callbacks, if present, must use the exact compiler-validated callback ABI and must not unwind. The native routine retains no pointer. Callers must link the documented GNU MinGW-compatible provider and serialize any process-global SLATEC state.
#[link_name = "cgamma_"]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/cgamma.md"))]
pub fn cgamma(z: *mut crate::Complex32) -> crate::Complex32;
}
// raw-api-routine: CGAMR
unsafe extern "C" {
/// Compute the reciprocal of the Gamma function.
///
/// Original SLATEC routine `CGAMR`; source: <https://www.netlib.org/slatec/fnlib/cgamr.f>; source SHA-256: `abb082a2293d5e9a58b7db3cce2f3c5b0102a83d4954b644eedadf973d100ffa`; native symbol: `cgamr_`.
/// Supported ABI: GNU MinGW `x86_64-pc-windows-gnu`; ABI class `complex_return`; fingerprint `function:complex32(mut_complex32)`.
/// Complex values use `crate::Complex32` or `crate::Complex64` in real/imaginary order. Complex arguments are passed by pointer; complex function results use the compiler-probed direct aggregate-return convention.
///
/// # Arguments
///
/// - `Z`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - Return: compiler-validated Fortran `COMPLEX` value.
///
/// # Safety
///
/// This declaration is source/hash, symbol, ABI-profile, compile, and bulk-link validated; it is not a safe or universally numerically validated API. Every pointer must be non-null, aligned, and valid for every native access; array storage, strides, leading dimensions, workspace, and aliasing must satisfy the selected source prologue. Rust callbacks, if present, must use the exact compiler-validated callback ABI and must not unwind. The native routine retains no pointer. Callers must link the documented GNU MinGW-compatible provider and serialize any process-global SLATEC state.
#[link_name = "cgamr_"]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/cgamr.md"))]
pub fn cgamr(z: *mut crate::Complex32) -> crate::Complex32;
}
// raw-api-routine: CLBETA
unsafe extern "C" {
/// Compute the natural logarithm of the complete Beta function.
///
/// Original SLATEC routine `CLBETA`; source: <https://www.netlib.org/slatec/fnlib/clbeta.f>; source SHA-256: `86be78fb8f448d16e89c07596b2e4a9d18cbcb7a2be90e9dd9707e2d2164e022`; native symbol: `clbeta_`.
/// Supported ABI: GNU MinGW `x86_64-pc-windows-gnu`; ABI class `complex_return`; fingerprint `function:complex32(mut_complex32,mut_complex32)`.
/// Complex values use `crate::Complex32` or `crate::Complex64` in real/imaginary order. Complex arguments are passed by pointer; complex function results use the compiler-probed direct aggregate-return convention.
///
/// # Arguments
///
/// - `A`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - `B`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - Return: compiler-validated Fortran `COMPLEX` value.
///
/// # Safety
///
/// This declaration is source/hash, symbol, ABI-profile, compile, and bulk-link validated; it is not a safe or universally numerically validated API. Every pointer must be non-null, aligned, and valid for every native access; array storage, strides, leading dimensions, workspace, and aliasing must satisfy the selected source prologue. Rust callbacks, if present, must use the exact compiler-validated callback ABI and must not unwind. The native routine retains no pointer. Callers must link the documented GNU MinGW-compatible provider and serialize any process-global SLATEC state.
#[link_name = "clbeta_"]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/clbeta.md"))]
pub fn clbeta(a: *mut crate::Complex32, b: *mut crate::Complex32) -> crate::Complex32;
}
// raw-api-routine: CLNGAM
unsafe extern "C" {
/// Compute the logarithm of the absolute value of the Gamma function.
///
/// Original SLATEC routine `CLNGAM`; source: <https://www.netlib.org/slatec/fnlib/clngam.f>; source SHA-256: `c3f41043151eb5b7fd2a3feed5eebbeb1290e3819fe1da8814bf04307addeaf1`; native symbol: `clngam_`.
/// Supported ABI: GNU MinGW `x86_64-pc-windows-gnu`; ABI class `complex_return`; fingerprint `function:complex32(mut_complex32)`.
/// Complex values use `crate::Complex32` or `crate::Complex64` in real/imaginary order. Complex arguments are passed by pointer; complex function results use the compiler-probed direct aggregate-return convention.
///
/// # Arguments
///
/// - `ZIN`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - Return: compiler-validated Fortran `COMPLEX` value.
///
/// # Safety
///
/// This declaration is source/hash, symbol, ABI-profile, compile, and bulk-link validated; it is not a safe or universally numerically validated API. Every pointer must be non-null, aligned, and valid for every native access; array storage, strides, leading dimensions, workspace, and aliasing must satisfy the selected source prologue. Rust callbacks, if present, must use the exact compiler-validated callback ABI and must not unwind. The native routine retains no pointer. Callers must link the documented GNU MinGW-compatible provider and serialize any process-global SLATEC state.
#[link_name = "clngam_"]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/clngam.md"))]
pub fn clngam(zin: *mut crate::Complex32) -> crate::Complex32;
}
// raw-api-routine: CLNREL
unsafe extern "C" {
/// Evaluate ln(1+X) accurate in the sense of relative error.
///
/// Original SLATEC routine `CLNREL`; source: <https://www.netlib.org/slatec/fnlib/clnrel.f>; source SHA-256: `9bddebfb17e45e6fa067777e2bcc547b81c3bf0e58e1632286eaa34edf59e1a3`; native symbol: `clnrel_`.
/// Supported ABI: GNU MinGW `x86_64-pc-windows-gnu`; ABI class `complex_return`; fingerprint `function:complex32(mut_complex32)`.
/// Complex values use `crate::Complex32` or `crate::Complex64` in real/imaginary order. Complex arguments are passed by pointer; complex function results use the compiler-probed direct aggregate-return convention.
///
/// # Arguments
///
/// - `Z`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - Return: compiler-validated Fortran `COMPLEX` value.
///
/// # Safety
///
/// This declaration is source/hash, symbol, ABI-profile, compile, and bulk-link validated; it is not a safe or universally numerically validated API. Every pointer must be non-null, aligned, and valid for every native access; array storage, strides, leading dimensions, workspace, and aliasing must satisfy the selected source prologue. Rust callbacks, if present, must use the exact compiler-validated callback ABI and must not unwind. The native routine retains no pointer. Callers must link the documented GNU MinGW-compatible provider and serialize any process-global SLATEC state.
#[link_name = "clnrel_"]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/clnrel.md"))]
pub fn clnrel(z: *mut crate::Complex32) -> crate::Complex32;
}
// raw-api-routine: CLOG10
unsafe extern "C" {
/// Compute the principal value of the complex base 10 logarithm.
///
/// Original SLATEC routine `CLOG10`; source: <https://www.netlib.org/slatec/fnlib/clog10.f>; source SHA-256: `94e77930b284d0d94eb7c5de2965038df97874e897bea9416a3800bd33ab341f`; native symbol: `clog10_`.
/// Supported ABI: GNU MinGW `x86_64-pc-windows-gnu`; ABI class `complex_return`; fingerprint `function:complex32(mut_complex32)`.
/// Complex values use `crate::Complex32` or `crate::Complex64` in real/imaginary order. Complex arguments are passed by pointer; complex function results use the compiler-probed direct aggregate-return convention.
///
/// # Arguments
///
/// - `Z`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - Return: compiler-validated Fortran `COMPLEX` value.
///
/// # Safety
///
/// This declaration is source/hash, symbol, ABI-profile, compile, and bulk-link validated; it is not a safe or universally numerically validated API. Every pointer must be non-null, aligned, and valid for every native access; array storage, strides, leading dimensions, workspace, and aliasing must satisfy the selected source prologue. Rust callbacks, if present, must use the exact compiler-validated callback ABI and must not unwind. The native routine retains no pointer. Callers must link the documented GNU MinGW-compatible provider and serialize any process-global SLATEC state.
#[link_name = "clog10_"]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/clog10.md"))]
pub fn clog10(z: *mut crate::Complex32) -> crate::Complex32;
}
// raw-api-routine: CPSI
unsafe extern "C" {
/// Compute the Psi (or Digamma) function.
///
/// Original SLATEC routine `CPSI`; source: <https://www.netlib.org/slatec/fnlib/cpsi.f>; source SHA-256: `6651fde59d3825140b2b58aa34bcf7ae8850ea6784f670586026d61c95c0ae32`; native symbol: `cpsi_`.
/// Supported ABI: GNU MinGW `x86_64-pc-windows-gnu`; ABI class `complex_return`; fingerprint `function:complex32(mut_complex32)`.
/// Complex values use `crate::Complex32` or `crate::Complex64` in real/imaginary order. Complex arguments are passed by pointer; complex function results use the compiler-probed direct aggregate-return convention.
///
/// # Arguments
///
/// - `ZIN`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - Return: compiler-validated Fortran `COMPLEX` value.
///
/// # Safety
///
/// This declaration is source/hash, symbol, ABI-profile, compile, and bulk-link validated; it is not a safe or universally numerically validated API. Every pointer must be non-null, aligned, and valid for every native access; array storage, strides, leading dimensions, workspace, and aliasing must satisfy the selected source prologue. Rust callbacks, if present, must use the exact compiler-validated callback ABI and must not unwind. The native routine retains no pointer. Callers must link the documented GNU MinGW-compatible provider and serialize any process-global SLATEC state.
#[link_name = "cpsi_"]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/cpsi.md"))]
pub fn cpsi(zin: *mut crate::Complex32) -> crate::Complex32;
}
// raw-api-routine: CSINH
unsafe extern "C" {
/// Compute the complex hyperbolic sine.
///
/// Original SLATEC routine `CSINH`; source: <https://www.netlib.org/slatec/fnlib/csinh.f>; source SHA-256: `c29c84f9c7975783b457eb75514e465d2530ddc1c095377f018166029b165c1a`; native symbol: `csinh_`.
/// Supported ABI: GNU MinGW `x86_64-pc-windows-gnu`; ABI class `complex_return`; fingerprint `function:complex32(mut_complex32)`.
/// Complex values use `crate::Complex32` or `crate::Complex64` in real/imaginary order. Complex arguments are passed by pointer; complex function results use the compiler-probed direct aggregate-return convention.
///
/// # Arguments
///
/// - `Z`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - Return: compiler-validated Fortran `COMPLEX` value.
///
/// # Safety
///
/// This declaration is source/hash, symbol, ABI-profile, compile, and bulk-link validated; it is not a safe or universally numerically validated API. Every pointer must be non-null, aligned, and valid for every native access; array storage, strides, leading dimensions, workspace, and aliasing must satisfy the selected source prologue. Rust callbacks, if present, must use the exact compiler-validated callback ABI and must not unwind. The native routine retains no pointer. Callers must link the documented GNU MinGW-compatible provider and serialize any process-global SLATEC state.
#[link_name = "csinh_"]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/csinh.md"))]
pub fn csinh(z: *mut crate::Complex32) -> crate::Complex32;
}
// raw-api-routine: CTAN
unsafe extern "C" {
/// Compute the complex tangent.
///
/// Original SLATEC routine `CTAN`; source: <https://www.netlib.org/slatec/fnlib/ctan.f>; source SHA-256: `b2c78e16b5d82b1e4b2568240545ef9613eab23c24f5f90489b17233aeff130e`; native symbol: `ctan_`.
/// Supported ABI: GNU MinGW `x86_64-pc-windows-gnu`; ABI class `complex_return`; fingerprint `function:complex32(mut_complex32)`.
/// Complex values use `crate::Complex32` or `crate::Complex64` in real/imaginary order. Complex arguments are passed by pointer; complex function results use the compiler-probed direct aggregate-return convention.
///
/// # Arguments
///
/// - `Z`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - Return: compiler-validated Fortran `COMPLEX` value.
///
/// # Safety
///
/// This declaration is source/hash, symbol, ABI-profile, compile, and bulk-link validated; it is not a safe or universally numerically validated API. Every pointer must be non-null, aligned, and valid for every native access; array storage, strides, leading dimensions, workspace, and aliasing must satisfy the selected source prologue. Rust callbacks, if present, must use the exact compiler-validated callback ABI and must not unwind. The native routine retains no pointer. Callers must link the documented GNU MinGW-compatible provider and serialize any process-global SLATEC state.
#[link_name = "ctan_"]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/ctan.md"))]
pub fn ctan(z: *mut crate::Complex32) -> crate::Complex32;
}
// raw-api-routine: CTANH
unsafe extern "C" {
/// Compute the complex hyperbolic tangent.
///
/// Original SLATEC routine `CTANH`; source: <https://www.netlib.org/slatec/fnlib/ctanh.f>; source SHA-256: `7ee2add33d316d1bd2f98974669c273e1b411a2a3a82718d200e434073d86931`; native symbol: `ctanh_`.
/// Supported ABI: GNU MinGW `x86_64-pc-windows-gnu`; ABI class `complex_return`; fingerprint `function:complex32(mut_complex32)`.
/// Complex values use `crate::Complex32` or `crate::Complex64` in real/imaginary order. Complex arguments are passed by pointer; complex function results use the compiler-probed direct aggregate-return convention.
///
/// # Arguments
///
/// - `Z`: Fortran `COMPLEX` scalar. Null is not permitted; provide the complete source-defined readable/writable extent. Semantic intent, aliasing permission, and exact extent/workspace formulas remain source-prologue obligations. The native routine does not retain the pointer.
/// - Return: compiler-validated Fortran `COMPLEX` value.
///
/// # Safety
///
/// This declaration is source/hash, symbol, ABI-profile, compile, and bulk-link validated; it is not a safe or universally numerically validated API. Every pointer must be non-null, aligned, and valid for every native access; array storage, strides, leading dimensions, workspace, and aliasing must satisfy the selected source prologue. Rust callbacks, if present, must use the exact compiler-validated callback ABI and must not unwind. The native routine retains no pointer. Callers must link the documented GNU MinGW-compatible provider and serialize any process-global SLATEC state.
#[link_name = "ctanh_"]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/ctanh.md"))]
pub fn ctanh(z: *mut crate::Complex32) -> crate::Complex32;
}