//! Canonical reviewed raw BLAS declarations.
//!
//! This file is generated by `slatec-corpus generate-raw-api-inventory --offline`.
//! Do not edit it directly; the R2A source-hash-guarded BLAS policy and selected
//! source metadata are the review inputs.
/// Reviewed public BLAS Level 1 raw routines.
#[cfg(any(
feature = "blas-level1",
feature = "raw-family-blas-level1",
feature = "raw-family-blas-complex"
))]
pub mod level1 {
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: CAXPY
/// Original SLATEC routine `CAXPY`.
/// Computes `Y <- alpha * X + Y` for the selected scalar type.
/// Mathematical operation: AXPY vector update. BLAS Level 1; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-a828f8ae9155ec52`; source: <https://www.netlib.org/slatec/lin/caxpy.f>; native symbol: `caxpy_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `CA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `CX`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `CY`: output or in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/caxpy.md"))]
pub use crate::generated::blas::caxpy;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: CCOPY
/// Original SLATEC routine `CCOPY`.
/// Executes the selected BLAS-family vector copy operation.
/// Mathematical operation: vector copy. BLAS Level 1; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-15eb0bebdb3d133d`; source: <https://www.netlib.org/slatec/lin/ccopy.f>; native symbol: `ccopy_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `CX`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `CY`: output or in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/ccopy.md"))]
pub use crate::generated::blas::ccopy;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: CROTG
/// Original SLATEC routine `CROTG`.
/// Executes the selected BLAS-family plane-rotation parameter generation operation.
/// Mathematical operation: plane-rotation parameter generation. BLAS Level 1; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-8a9ba1dd16fb8f0f`; source: <https://www.netlib.org/slatec/lin/crotg.f>; native symbol: `crotg_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `CA`: In/out scalar rotation-generator operand; the selected routine overwrites it with its documented transformed value.
/// - `CB`: In/out scalar rotation-generator operand; the selected routine overwrites it with its documented transformed value.
/// - `C`: Output real rotation cosine written by the selected parameter generator.
/// - `S`: Output rotation sine written by the selected parameter generator.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/crotg.md"))]
pub use crate::generated::blas::crotg;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: CSCAL
/// Original SLATEC routine `CSCAL`.
/// Executes the selected BLAS-family vector scaling operation.
/// Mathematical operation: vector scaling. BLAS Level 1; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-63227f654a7c202c`; source: <https://www.netlib.org/slatec/lin/cscal.f>; native symbol: `cscal_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `CA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `CX`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/cscal.md"))]
pub use crate::generated::blas::cscal;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: CSROT
/// Original SLATEC routine `CSROT`.
/// Executes the selected BLAS-family plane rotation operation.
/// Mathematical operation: plane rotation. BLAS Level 1; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-5f3b99d5cf3ff767`; source: <https://www.netlib.org/slatec/lin/csrot.f>; native symbol: `csrot_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `CX`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `CY`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `C`: Input real rotation cosine used for the selected plane rotation.
/// - `S`: Input rotation sine used for the selected plane rotation.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/csrot.md"))]
pub use crate::generated::blas::csrot;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: CSSCAL
/// Original SLATEC routine `CSSCAL`.
/// Executes the selected BLAS-family vector scaling operation.
/// Mathematical operation: vector scaling. BLAS Level 1; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-beca447988becea1`; source: <https://www.netlib.org/slatec/lin/csscal.f>; native symbol: `csscal_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `SA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `CX`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/csscal.md"))]
pub use crate::generated::blas::csscal;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: CSWAP
/// Original SLATEC routine `CSWAP`.
/// Executes the selected BLAS-family vector swap operation.
/// Mathematical operation: vector swap. BLAS Level 1; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-917a4873e5d41f79`; source: <https://www.netlib.org/slatec/lin/cswap.f>; native symbol: `cswap_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `CX`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `CY`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/cswap.md"))]
pub use crate::generated::blas::cswap;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: DASUM
/// Original SLATEC routine `DASUM`.
/// Executes the selected BLAS-family sum of vector magnitudes operation.
/// Mathematical operation: sum of vector magnitudes. BLAS Level 1; scalar profile: `f64`.
/// Selected provider: `full-provider-8fd6283cb1142d44`; source: <https://www.netlib.org/slatec/lin/dasum.f>; native symbol: `dasum_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `DX`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dasum.md"))]
pub use crate::generated::blas::dasum;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: DAXPY
/// Original SLATEC routine `DAXPY`.
/// Computes `Y <- alpha * X + Y` for the selected scalar type.
/// Mathematical operation: AXPY vector update. BLAS Level 1; scalar profile: `f64`.
/// Selected provider: `full-provider-f31ee65504b5a1da`; source: <https://www.netlib.org/slatec/lin/daxpy.f>; native symbol: `daxpy_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `DA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `DX`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `DY`: output or in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/daxpy.md"))]
pub use crate::generated::blas::daxpy;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: DCDOT
/// Original SLATEC routine `DCDOT`.
/// Executes the selected BLAS-family dot product operation.
/// Mathematical operation: dot product. BLAS Level 1; scalar profile: `f64`.
/// Selected provider: `full-provider-7e9b2ebbd88c8ec8`; source: <https://www.netlib.org/slatec/lin/dcdot.f>; native symbol: `dcdot_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `FM`: Input scale or mode argument used by the selected extended dot helper.
/// - `CX`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `CY`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `DCR`: Output real or imaginary component written by the selected extended complex dot helper.
/// - `DCI`: Output real or imaginary component written by the selected extended complex dot helper.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dcdot.md"))]
pub use crate::generated::blas::dcdot;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: DCOPY
/// Original SLATEC routine `DCOPY`.
/// Executes the selected BLAS-family vector copy operation.
/// Mathematical operation: vector copy. BLAS Level 1; scalar profile: `f64`.
/// Selected provider: `full-provider-11066d5d32da9d80`; source: <https://www.netlib.org/slatec/lin/dcopy.f>; native symbol: `dcopy_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `DX`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `DY`: output or in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dcopy.md"))]
pub use crate::generated::blas::dcopy;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: DCOPYM
/// Original SLATEC routine `DCOPYM`.
/// Executes the selected BLAS-family vector copy operation.
/// Mathematical operation: vector copy. BLAS Level 1; scalar profile: `f64`.
/// Selected provider: `full-provider-474201223513ac06`; source: <https://www.netlib.org/slatec/lin/dcopym.f>; native symbol: `dcopym_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `DX`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `DY`: output or in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dcopym.md"))]
pub use crate::generated::blas::dcopym;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: DDOT
/// Original SLATEC routine `DDOT`.
/// Executes the selected BLAS-family dot product operation.
/// Mathematical operation: dot product. BLAS Level 1; scalar profile: `f64`.
/// Selected provider: `full-provider-844cb3a9fca9c8fd`; source: <https://www.netlib.org/slatec/lin/ddot.f>; native symbol: `ddot_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `DX`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `DY`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/ddot.md"))]
pub use crate::generated::blas::ddot;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: DNRM2
/// Original SLATEC routine `DNRM2`.
/// Executes the selected BLAS-family Euclidean vector norm operation.
/// Mathematical operation: Euclidean vector norm. BLAS Level 1; scalar profile: `f64`.
/// Selected provider: `full-provider-010420d14360a2c6`; source: <https://www.netlib.org/slatec/lin/dnrm2.f>; native symbol: `dnrm2_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `DX`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. The selected norm source requires `INCX >= 1`; this raw interface does not normalize a zero or negative increment.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dnrm2.md"))]
pub use crate::generated::blas::dnrm2;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: DQDOTA
/// Original SLATEC routine `DQDOTA`.
/// Executes the selected BLAS-family dot product operation.
/// Mathematical operation: dot product. BLAS Level 1; scalar profile: `f64`.
/// Selected provider: `full-provider-af0c74193d616b71`; source: <https://www.netlib.org/slatec/src/dqdota.f>; native symbol: `dqdota_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `DB`: Fortran scalar or array argument with the selected source-defined input/output semantics; it must be non-null and valid for the native access.
/// - `QC`: Fortran scalar or array argument with the selected source-defined input/output semantics; it must be non-null and valid for the native access.
/// - `DX`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `DY`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dqdota.md"))]
pub use crate::generated::blas::dqdota;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: DQDOTI
/// Original SLATEC routine `DQDOTI`.
/// Executes the selected BLAS-family dot product operation.
/// Mathematical operation: dot product. BLAS Level 1; scalar profile: `f64`.
/// Selected provider: `full-provider-d2b2e0f305eee7bd`; source: <https://www.netlib.org/slatec/src/dqdoti.f>; native symbol: `dqdoti_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `DB`: Fortran scalar or array argument with the selected source-defined input/output semantics; it must be non-null and valid for the native access.
/// - `QC`: Fortran scalar or array argument with the selected source-defined input/output semantics; it must be non-null and valid for the native access.
/// - `DX`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `DY`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dqdoti.md"))]
pub use crate::generated::blas::dqdoti;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: DROT
/// Original SLATEC routine `DROT`.
/// Executes the selected BLAS-family plane rotation operation.
/// Mathematical operation: plane rotation. BLAS Level 1; scalar profile: `f64`.
/// Selected provider: `full-provider-e03fe1d3ee149237`; source: <https://www.netlib.org/slatec/lin/drot.f>; native symbol: `drot_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `DX`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `DY`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `DC`: Input real rotation coefficient used for the selected plane rotation.
/// - `DS`: Input real rotation coefficient used for the selected plane rotation.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/drot.md"))]
pub use crate::generated::blas::drot;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: DROTG
/// Original SLATEC routine `DROTG`.
/// Executes the selected BLAS-family plane-rotation parameter generation operation.
/// Mathematical operation: plane-rotation parameter generation. BLAS Level 1; scalar profile: `f64`.
/// Selected provider: `full-provider-43222b6f19aacb9e`; source: <https://www.netlib.org/slatec/lin/drotg.f>; native symbol: `drotg_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `DA`: In/out scalar rotation-generator operand; the selected routine overwrites it with its documented transformed value.
/// - `DB`: In/out scalar rotation-generator operand; the selected routine overwrites it with its documented transformed value.
/// - `DC`: Input real rotation coefficient used for the selected plane rotation.
/// - `DS`: Input real rotation coefficient used for the selected plane rotation.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/drotg.md"))]
pub use crate::generated::blas::drotg;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: DROTM
/// Original SLATEC routine `DROTM`.
/// Executes the selected BLAS-family modified plane rotation operation.
/// Mathematical operation: modified plane rotation. BLAS Level 1; scalar profile: `f64`.
/// Selected provider: `full-provider-ae71704ca459e80b`; source: <https://www.netlib.org/slatec/lin/drotm.f>; native symbol: `drotm_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `DX`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `DY`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `DPARAM`: In/out rotation-parameter array with the source-defined fixed layout; it must be writable for all documented parameter slots.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/drotm.md"))]
pub use crate::generated::blas::drotm;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: DROTMG
/// Original SLATEC routine `DROTMG`.
/// Executes the selected BLAS-family modified plane-rotation parameter generation operation.
/// Mathematical operation: modified plane-rotation parameter generation. BLAS Level 1; scalar profile: `f64`.
/// Selected provider: `full-provider-325503c5e8104509`; source: <https://www.netlib.org/slatec/lin/drotmg.f>; native symbol: `drotmg_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `DD1`: In/out scalar used by the modified rotation parameter generator.
/// - `DD2`: In/out scalar used by the modified rotation parameter generator.
/// - `DX1`: In/out scalar used by the modified rotation parameter generator.
/// - `DY1`: In/out scalar used by the modified rotation parameter generator.
/// - `DPARAM`: In/out rotation-parameter array with the source-defined fixed layout; it must be writable for all documented parameter slots.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/drotmg.md"))]
pub use crate::generated::blas::drotmg;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: DS2Y
/// Original SLATEC routine `DS2Y`.
/// Executes the selected BLAS-family selected BLAS helper operation.
/// Mathematical operation: selected BLAS helper. BLAS Level 1; scalar profile: `f64`.
/// Selected provider: `full-provider-b4b07b09ee6ea3bc`; source: <https://www.netlib.org/slatec/lin/ds2y.f>; native symbol: `ds2y_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `NELT`: Input count of stored sparse elements for the selected helper.
/// - `IA`: Input integer index storage for the selected sparse-format helper.
/// - `JA`: Input integer index storage for the selected sparse-format helper.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `ISYM`: Input storage-symmetry selector used by the selected sparse-format helper.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/ds2y.md"))]
pub use crate::generated::blas::ds2y;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: DSCAL
/// Original SLATEC routine `DSCAL`.
/// Executes the selected BLAS-family vector scaling operation.
/// Mathematical operation: vector scaling. BLAS Level 1; scalar profile: `f64`.
/// Selected provider: `full-provider-a9ae7eaae41546ca`; source: <https://www.netlib.org/slatec/lin/dscal.f>; native symbol: `dscal_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `DA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `DX`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dscal.md"))]
pub use crate::generated::blas::dscal;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: DSDI
/// Original SLATEC routine `DSDI`.
/// Executes the selected BLAS-family selected BLAS helper operation.
/// Mathematical operation: selected BLAS helper. BLAS Level 1; scalar profile: `f64`.
/// Selected provider: `full-provider-2399cdd0ec04a433`; source: <https://www.netlib.org/slatec/lin/dsdi.f>; native symbol: `dsdi_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `B`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `NELT`: Input count of stored sparse elements for the selected helper.
/// - `IA`: Input integer index storage for the selected sparse-format helper.
/// - `JA`: Input integer index storage for the selected sparse-format helper.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `ISYM`: Input storage-symmetry selector used by the selected sparse-format helper.
/// - `RWORK`: Fortran scalar or array argument with the selected source-defined input/output semantics; it must be non-null and valid for the native access.
/// - `IWORK`: Fortran scalar or array argument with the selected source-defined input/output semantics; it must be non-null and valid for the native access.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dsdi.md"))]
pub use crate::generated::blas::dsdi;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: DSDOT
/// Original SLATEC routine `DSDOT`.
/// Executes the selected BLAS-family dot product operation.
/// Mathematical operation: dot product. BLAS Level 1; scalar profile: `f64`.
/// Selected provider: `full-provider-8a640da19612cca2`; source: <https://www.netlib.org/slatec/lin/dsdot.f>; native symbol: `dsdot_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `SX`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `SY`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dsdot.md"))]
pub use crate::generated::blas::dsdot;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: DSMTV
/// Original SLATEC routine `DSMTV`.
/// Executes the selected BLAS-family selected BLAS helper operation.
/// Mathematical operation: selected BLAS helper. BLAS Level 1; scalar profile: `f64`.
/// Selected provider: `full-provider-77550de0c456ca42`; source: <https://www.netlib.org/slatec/lin/dsmtv.f>; native symbol: `dsmtv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `Y`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `NELT`: Input count of stored sparse elements for the selected helper.
/// - `IA`: Input integer index storage for the selected sparse-format helper.
/// - `JA`: Input integer index storage for the selected sparse-format helper.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `ISYM`: Input storage-symmetry selector used by the selected sparse-format helper.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dsmtv.md"))]
pub use crate::generated::blas::dsmtv;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: DSMV
/// Original SLATEC routine `DSMV`.
/// Executes the selected BLAS-family selected BLAS helper operation.
/// Mathematical operation: selected BLAS helper. BLAS Level 1; scalar profile: `f64`.
/// Selected provider: `full-provider-b432c46228b5d754`; source: <https://www.netlib.org/slatec/lin/dsmv.f>; native symbol: `dsmv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `Y`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `NELT`: Input count of stored sparse elements for the selected helper.
/// - `IA`: Input integer index storage for the selected sparse-format helper.
/// - `JA`: Input integer index storage for the selected sparse-format helper.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `ISYM`: Input storage-symmetry selector used by the selected sparse-format helper.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dsmv.md"))]
pub use crate::generated::blas::dsmv;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: DSWAP
/// Original SLATEC routine `DSWAP`.
/// Executes the selected BLAS-family vector swap operation.
/// Mathematical operation: vector swap. BLAS Level 1; scalar profile: `f64`.
/// Selected provider: `full-provider-4093a09ebc087c32`; source: <https://www.netlib.org/slatec/lin/dswap.f>; native symbol: `dswap_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `DX`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `DY`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dswap.md"))]
pub use crate::generated::blas::dswap;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: ICAMAX
/// Original SLATEC routine `ICAMAX`.
/// Executes the selected BLAS-family index of maximum vector magnitude operation.
/// Mathematical operation: index of maximum vector magnitude. BLAS Level 1; scalar profile: `integer_or_index`.
/// Selected provider: `full-provider-4532a955646429a9`; source: <https://www.netlib.org/slatec/lin/icamax.f>; native symbol: `icamax_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `CX`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/icamax.md"))]
pub use crate::generated::blas::icamax;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: ICOPY
/// Original SLATEC routine `ICOPY`.
/// Executes the selected BLAS-family vector copy operation.
/// Mathematical operation: vector copy. BLAS Level 1; scalar profile: `integer_or_index`.
/// Selected provider: `full-provider-d49135baa9eefae8`; source: <https://www.netlib.org/slatec/lin/icopy.f>; native symbol: `icopy_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `IX`: Fortran scalar or array argument with the selected source-defined input/output semantics; it must be non-null and valid for the native access.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `IY`: Fortran scalar or array argument with the selected source-defined input/output semantics; it must be non-null and valid for the native access.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/icopy.md"))]
pub use crate::generated::blas::icopy;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: IDAMAX
/// Original SLATEC routine `IDAMAX`.
/// Executes the selected BLAS-family index of maximum vector magnitude operation.
/// Mathematical operation: index of maximum vector magnitude. BLAS Level 1; scalar profile: `integer_or_index`.
/// Selected provider: `full-provider-03dd7cd6ab981b5d`; source: <https://www.netlib.org/slatec/lin/idamax.f>; native symbol: `idamax_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `DX`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/idamax.md"))]
pub use crate::generated::blas::idamax;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: ISAMAX
/// Original SLATEC routine `ISAMAX`.
/// Executes the selected BLAS-family index of maximum vector magnitude operation.
/// Mathematical operation: index of maximum vector magnitude. BLAS Level 1; scalar profile: `integer_or_index`.
/// Selected provider: `full-provider-1d3cb7d5594f5db1`; source: <https://www.netlib.org/slatec/lin/isamax.f>; native symbol: `isamax_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `SX`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/isamax.md"))]
pub use crate::generated::blas::isamax;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: ISWAP
/// Original SLATEC routine `ISWAP`.
/// Executes the selected BLAS-family vector swap operation.
/// Mathematical operation: vector swap. BLAS Level 1; scalar profile: `integer_or_index`.
/// Selected provider: `full-provider-8983ef6bd4abf192`; source: <https://www.netlib.org/slatec/lin/iswap.f>; native symbol: `iswap_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `IX`: Fortran scalar or array argument with the selected source-defined input/output semantics; it must be non-null and valid for the native access.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `IY`: Fortran scalar or array argument with the selected source-defined input/output semantics; it must be non-null and valid for the native access.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/iswap.md"))]
pub use crate::generated::blas::iswap;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: SASUM
/// Original SLATEC routine `SASUM`.
/// Executes the selected BLAS-family sum of vector magnitudes operation.
/// Mathematical operation: sum of vector magnitudes. BLAS Level 1; scalar profile: `f32`.
/// Selected provider: `full-provider-014398e8138837ef`; source: <https://www.netlib.org/slatec/lin/sasum.f>; native symbol: `sasum_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `SX`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/sasum.md"))]
pub use crate::generated::blas::sasum;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: SAXPY
/// Original SLATEC routine `SAXPY`.
/// Computes `Y <- alpha * X + Y` for the selected scalar type.
/// Mathematical operation: AXPY vector update. BLAS Level 1; scalar profile: `f32`.
/// Selected provider: `full-provider-d106ad3804c20e5d`; source: <https://www.netlib.org/slatec/lin/saxpy.f>; native symbol: `saxpy_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `SA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `SX`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `SY`: output or in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/saxpy.md"))]
pub use crate::generated::blas::saxpy;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: SCASUM
/// Original SLATEC routine `SCASUM`.
/// Executes the selected BLAS-family sum of vector magnitudes operation.
/// Mathematical operation: sum of vector magnitudes. BLAS Level 1; scalar profile: `f32`.
/// Selected provider: `full-provider-fe7cbad40e766d94`; source: <https://www.netlib.org/slatec/lin/scasum.f>; native symbol: `scasum_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `CX`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/scasum.md"))]
pub use crate::generated::blas::scasum;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: SCNRM2
/// Original SLATEC routine `SCNRM2`.
/// Executes the selected BLAS-family Euclidean vector norm operation.
/// Mathematical operation: Euclidean vector norm. BLAS Level 1; scalar profile: `f32`.
/// Selected provider: `full-provider-1a6c2cdacbe051fe`; source: <https://www.netlib.org/slatec/lin/scnrm2.f>; native symbol: `scnrm2_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `CX`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. The selected norm source requires `INCX >= 1`; this raw interface does not normalize a zero or negative increment.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/scnrm2.md"))]
pub use crate::generated::blas::scnrm2;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: SCOPY
/// Original SLATEC routine `SCOPY`.
/// Executes the selected BLAS-family vector copy operation.
/// Mathematical operation: vector copy. BLAS Level 1; scalar profile: `f32`.
/// Selected provider: `full-provider-ce5228372c90647f`; source: <https://www.netlib.org/slatec/lin/scopy.f>; native symbol: `scopy_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `SX`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `SY`: output or in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/scopy.md"))]
pub use crate::generated::blas::scopy;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: SCOPYM
/// Original SLATEC routine `SCOPYM`.
/// Executes the selected BLAS-family vector copy operation.
/// Mathematical operation: vector copy. BLAS Level 1; scalar profile: `f32`.
/// Selected provider: `full-provider-744de4b9dba3e473`; source: <https://www.netlib.org/slatec/lin/scopym.f>; native symbol: `scopym_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `SX`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `SY`: output or in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/scopym.md"))]
pub use crate::generated::blas::scopym;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: SDOT
/// Original SLATEC routine `SDOT`.
/// Executes the selected BLAS-family dot product operation.
/// Mathematical operation: dot product. BLAS Level 1; scalar profile: `f32`.
/// Selected provider: `full-provider-35f2e5e233709c3e`; source: <https://www.netlib.org/slatec/lin/sdot.f>; native symbol: `sdot_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `SX`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `SY`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/sdot.md"))]
pub use crate::generated::blas::sdot;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: SDSDOT
/// Original SLATEC routine `SDSDOT`.
/// Executes the selected BLAS-family dot product operation.
/// Mathematical operation: dot product. BLAS Level 1; scalar profile: `f32`.
/// Selected provider: `full-provider-7d569b29bc902d6e`; source: <https://www.netlib.org/slatec/lin/sdsdot.f>; native symbol: `sdsdot_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `SB`: Fortran scalar or array argument with the selected source-defined input/output semantics; it must be non-null and valid for the native access.
/// - `SX`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `SY`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/sdsdot.md"))]
pub use crate::generated::blas::sdsdot;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: SNRM2
/// Original SLATEC routine `SNRM2`.
/// Executes the selected BLAS-family Euclidean vector norm operation.
/// Mathematical operation: Euclidean vector norm. BLAS Level 1; scalar profile: `f32`.
/// Selected provider: `full-provider-f3a1afce36b35827`; source: <https://www.netlib.org/slatec/lin/snrm2.f>; native symbol: `snrm2_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `SX`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. The selected norm source requires `INCX >= 1`; this raw interface does not normalize a zero or negative increment.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/snrm2.md"))]
pub use crate::generated::blas::snrm2;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: SROT
/// Original SLATEC routine `SROT`.
/// Executes the selected BLAS-family plane rotation operation.
/// Mathematical operation: plane rotation. BLAS Level 1; scalar profile: `f32`.
/// Selected provider: `full-provider-f2f32b7a6a41f5db`; source: <https://www.netlib.org/slatec/lin/srot.f>; native symbol: `srot_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `SX`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `SY`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `SC`: Input real rotation coefficient used for the selected plane rotation.
/// - `SS`: Input real rotation coefficient used for the selected plane rotation.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/srot.md"))]
pub use crate::generated::blas::srot;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: SROTG
/// Original SLATEC routine `SROTG`.
/// Executes the selected BLAS-family plane-rotation parameter generation operation.
/// Mathematical operation: plane-rotation parameter generation. BLAS Level 1; scalar profile: `f32`.
/// Selected provider: `full-provider-eb362ae36217d81b`; source: <https://www.netlib.org/slatec/lin/srotg.f>; native symbol: `srotg_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `SA`: In/out scalar rotation-generator operand; the selected routine overwrites it with its documented transformed value.
/// - `SB`: In/out scalar rotation-generator operand; the selected routine overwrites it with its documented transformed value.
/// - `SC`: Input real rotation coefficient used for the selected plane rotation.
/// - `SS`: Input real rotation coefficient used for the selected plane rotation.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/srotg.md"))]
pub use crate::generated::blas::srotg;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: SROTM
/// Original SLATEC routine `SROTM`.
/// Executes the selected BLAS-family modified plane rotation operation.
/// Mathematical operation: modified plane rotation. BLAS Level 1; scalar profile: `f32`.
/// Selected provider: `full-provider-15c08111015fc650`; source: <https://www.netlib.org/slatec/lin/srotm.f>; native symbol: `srotm_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `SX`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `SY`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `SPARAM`: In/out rotation-parameter array with the source-defined fixed layout; it must be writable for all documented parameter slots.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/srotm.md"))]
pub use crate::generated::blas::srotm;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: SROTMG
/// Original SLATEC routine `SROTMG`.
/// Executes the selected BLAS-family modified plane-rotation parameter generation operation.
/// Mathematical operation: modified plane-rotation parameter generation. BLAS Level 1; scalar profile: `f32`.
/// Selected provider: `full-provider-873252c3bf1cb060`; source: <https://www.netlib.org/slatec/lin/srotmg.f>; native symbol: `srotmg_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `SD1`: Fortran scalar or array argument with the selected source-defined input/output semantics; it must be non-null and valid for the native access.
/// - `SD2`: Fortran scalar or array argument with the selected source-defined input/output semantics; it must be non-null and valid for the native access.
/// - `SX1`: Fortran scalar or array argument with the selected source-defined input/output semantics; it must be non-null and valid for the native access.
/// - `SY1`: Fortran scalar or array argument with the selected source-defined input/output semantics; it must be non-null and valid for the native access.
/// - `SPARAM`: In/out rotation-parameter array with the source-defined fixed layout; it must be writable for all documented parameter slots.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/srotmg.md"))]
pub use crate::generated::blas::srotmg;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: SS2Y
/// Original SLATEC routine `SS2Y`.
/// Executes the selected BLAS-family selected BLAS helper operation.
/// Mathematical operation: selected BLAS helper. BLAS Level 1; scalar profile: `f32`.
/// Selected provider: `full-provider-7ae795c9ca1ec042`; source: <https://www.netlib.org/slatec/lin/ss2y.f>; native symbol: `ss2y_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `NELT`: Input count of stored sparse elements for the selected helper.
/// - `IA`: Input integer index storage for the selected sparse-format helper.
/// - `JA`: Input integer index storage for the selected sparse-format helper.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `ISYM`: Input storage-symmetry selector used by the selected sparse-format helper.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/ss2y.md"))]
pub use crate::generated::blas::ss2y;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: SSCAL
/// Original SLATEC routine `SSCAL`.
/// Executes the selected BLAS-family vector scaling operation.
/// Mathematical operation: vector scaling. BLAS Level 1; scalar profile: `f32`.
/// Selected provider: `full-provider-09099ab5635b8fa3`; source: <https://www.netlib.org/slatec/lin/sscal.f>; native symbol: `sscal_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `SA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `SX`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/sscal.md"))]
pub use crate::generated::blas::sscal;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: SSDI
/// Original SLATEC routine `SSDI`.
/// Executes the selected BLAS-family selected BLAS helper operation.
/// Mathematical operation: selected BLAS helper. BLAS Level 1; scalar profile: `f32`.
/// Selected provider: `full-provider-1bffead7464cb4d5`; source: <https://www.netlib.org/slatec/lin/ssdi.f>; native symbol: `ssdi_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `B`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `NELT`: Input count of stored sparse elements for the selected helper.
/// - `IA`: Input integer index storage for the selected sparse-format helper.
/// - `JA`: Input integer index storage for the selected sparse-format helper.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `ISYM`: Input storage-symmetry selector used by the selected sparse-format helper.
/// - `RWORK`: Fortran scalar or array argument with the selected source-defined input/output semantics; it must be non-null and valid for the native access.
/// - `IWORK`: Fortran scalar or array argument with the selected source-defined input/output semantics; it must be non-null and valid for the native access.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/ssdi.md"))]
pub use crate::generated::blas::ssdi;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: SSMTV
/// Original SLATEC routine `SSMTV`.
/// Executes the selected BLAS-family selected BLAS helper operation.
/// Mathematical operation: selected BLAS helper. BLAS Level 1; scalar profile: `f32`.
/// Selected provider: `full-provider-e7d21ab1ff3f5477`; source: <https://www.netlib.org/slatec/lin/ssmtv.f>; native symbol: `ssmtv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `Y`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `NELT`: Input count of stored sparse elements for the selected helper.
/// - `IA`: Input integer index storage for the selected sparse-format helper.
/// - `JA`: Input integer index storage for the selected sparse-format helper.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `ISYM`: Input storage-symmetry selector used by the selected sparse-format helper.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/ssmtv.md"))]
pub use crate::generated::blas::ssmtv;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: SSMV
/// Original SLATEC routine `SSMV`.
/// Executes the selected BLAS-family selected BLAS helper operation.
/// Mathematical operation: selected BLAS helper. BLAS Level 1; scalar profile: `f32`.
/// Selected provider: `full-provider-f0f4464efaccf9b7`; source: <https://www.netlib.org/slatec/lin/ssmv.f>; native symbol: `ssmv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `Y`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `NELT`: Input count of stored sparse elements for the selected helper.
/// - `IA`: Input integer index storage for the selected sparse-format helper.
/// - `JA`: Input integer index storage for the selected sparse-format helper.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `ISYM`: Input storage-symmetry selector used by the selected sparse-format helper.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/ssmv.md"))]
pub use crate::generated::blas::ssmv;
#[cfg(any(feature = "blas-level1", feature = "raw-family-blas-level1"))]
// raw-api-routine: SSWAP
/// Original SLATEC routine `SSWAP`.
/// Executes the selected BLAS-family vector swap operation.
/// Mathematical operation: vector swap. BLAS Level 1; scalar profile: `f32`.
/// Selected provider: `full-provider-f52692fc8ca0bce9`; source: <https://www.netlib.org/slatec/lin/sswap.f>; native symbol: `sswap_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `SX`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `SY`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/sswap.md"))]
pub use crate::generated::blas::sswap;
/// Complex-return BLAS Level 1 functions.
#[cfg(feature = "raw-family-blas-complex")]
pub use crate::abi_bindings::blas::{cdcdot, cdotc, cdotu};
}
/// Reviewed public BLAS Level 2 raw routines.
#[cfg(any(feature = "blas-level2", feature = "raw-family-blas-level2"))]
pub mod level2 {
// raw-api-routine: CGBMV
/// Original SLATEC routine `CGBMV`.
/// Executes the selected BLAS-family general band matrix-vector multiply operation.
/// Mathematical operation: general band matrix-vector multiply. BLAS Level 2; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-de38e1a40a02ae8a`; source: <https://www.netlib.org/slatec/lin/cgbmv.f>; native symbol: `cgbmv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `TRANS`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `M`: Input row count. Matrix leading dimensions and operand storage must be valid for this selected dimension.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `KL`: Input number of stored sub- or super-diagonals in general band storage.
/// - `KU`: Input number of stored sub- or super-diagonals in general band storage.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `BETA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `Y`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/cgbmv.md"))]
pub use crate::generated::blas::cgbmv;
// raw-api-routine: CGEMV
/// Original SLATEC routine `CGEMV`.
/// Computes `Y <- alpha * op(A) * X + beta * Y` in column-major storage.
/// Mathematical operation: general matrix-vector multiply. BLAS Level 2; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-ee24fc12181b69b6`; source: <https://www.netlib.org/slatec/lin/cgemv.f>; native symbol: `cgemv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `TRANS`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `M`: Input row count. Matrix leading dimensions and operand storage must be valid for this selected dimension.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `BETA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `Y`: output or in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/cgemv.md"))]
pub use crate::generated::blas::cgemv;
// raw-api-routine: CGERC
/// Original SLATEC routine `CGERC`.
/// Executes the selected BLAS-family rank-one matrix update operation.
/// Mathematical operation: rank-one matrix update. BLAS Level 2; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-235d4d806af0d58d`; source: <https://www.netlib.org/slatec/lin/cgerc.f>; native symbol: `cgerc_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `M`: Input row count. Matrix leading dimensions and operand storage must be valid for this selected dimension.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `Y`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `A`: In/out column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/cgerc.md"))]
pub use crate::generated::blas::cgerc;
// raw-api-routine: CGERU
/// Original SLATEC routine `CGERU`.
/// Executes the selected BLAS-family rank-one matrix update operation.
/// Mathematical operation: rank-one matrix update. BLAS Level 2; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-446c7d29695500c2`; source: <https://www.netlib.org/slatec/lin/cgeru.f>; native symbol: `cgeru_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `M`: Input row count. Matrix leading dimensions and operand storage must be valid for this selected dimension.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `Y`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `A`: In/out column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/cgeru.md"))]
pub use crate::generated::blas::cgeru;
// raw-api-routine: CHBMV
/// Original SLATEC routine `CHBMV`.
/// Executes the selected BLAS-family symmetric or Hermitian matrix-vector multiply operation.
/// Mathematical operation: symmetric or Hermitian matrix-vector multiply. BLAS Level 2; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-db12cf89e98e7ead`; source: <https://www.netlib.org/slatec/lin/chbmv.f>; native symbol: `chbmv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `K`: Input inner or band dimension used by the selected operation.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `BETA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `Y`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/chbmv.md"))]
pub use crate::generated::blas::chbmv;
// raw-api-routine: CHEMV
/// Original SLATEC routine `CHEMV`.
/// Executes the selected BLAS-family symmetric or Hermitian matrix-vector multiply operation.
/// Mathematical operation: symmetric or Hermitian matrix-vector multiply. BLAS Level 2; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-f78ce911439cda4e`; source: <https://www.netlib.org/slatec/lin/chemv.f>; native symbol: `chemv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `BETA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `Y`: output or in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/chemv.md"))]
pub use crate::generated::blas::chemv;
// raw-api-routine: CHER
/// Original SLATEC routine `CHER`.
/// Executes the selected BLAS-family symmetric or Hermitian rank-one update operation.
/// Mathematical operation: symmetric or Hermitian rank-one update. BLAS Level 2; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-17d6b65f8f70c908`; source: <https://www.netlib.org/slatec/lin/cher.f>; native symbol: `cher_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `A`: In/out column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/cher.md"))]
pub use crate::generated::blas::cher;
// raw-api-routine: CHER2
/// Original SLATEC routine `CHER2`.
/// Executes the selected BLAS-family symmetric or Hermitian rank-two update operation.
/// Mathematical operation: symmetric or Hermitian rank-two update. BLAS Level 2; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-3028938981287cef`; source: <https://www.netlib.org/slatec/lin/cher2.f>; native symbol: `cher2_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `Y`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `A`: In/out column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/cher2.md"))]
pub use crate::generated::blas::cher2;
// raw-api-routine: CHPMV
/// Original SLATEC routine `CHPMV`.
/// Executes the selected BLAS-family symmetric or Hermitian matrix-vector multiply operation.
/// Mathematical operation: symmetric or Hermitian matrix-vector multiply. BLAS Level 2; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-8c1b7945f7e99717`; source: <https://www.netlib.org/slatec/lin/chpmv.f>; native symbol: `chpmv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `AP`: Packed symmetric, Hermitian, or triangular matrix storage. It is read or updated according to the selected operation and must contain the selected packed triangle.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `BETA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `Y`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/chpmv.md"))]
pub use crate::generated::blas::chpmv;
// raw-api-routine: CHPR
/// Original SLATEC routine `CHPR`.
/// Executes the selected BLAS-family symmetric or Hermitian rank-one update operation.
/// Mathematical operation: symmetric or Hermitian rank-one update. BLAS Level 2; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-31251dc268648097`; source: <https://www.netlib.org/slatec/lin/chpr.f>; native symbol: `chpr_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `AP`: Packed symmetric, Hermitian, or triangular matrix storage. It is read or updated according to the selected operation and must contain the selected packed triangle.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/chpr.md"))]
pub use crate::generated::blas::chpr;
// raw-api-routine: CHPR2
/// Original SLATEC routine `CHPR2`.
/// Executes the selected BLAS-family selected BLAS helper operation.
/// Mathematical operation: selected BLAS helper. BLAS Level 2; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-7d5e330e19a578a2`; source: <https://www.netlib.org/slatec/lin/chpr2.f>; native symbol: `chpr2_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `Y`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `AP`: Packed symmetric, Hermitian, or triangular matrix storage. It is read or updated according to the selected operation and must contain the selected packed triangle.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/chpr2.md"))]
pub use crate::generated::blas::chpr2;
// raw-api-routine: CTBMV
/// Original SLATEC routine `CTBMV`.
/// Multiplies a matrix or vector by a selected triangular matrix in-place.
/// Mathematical operation: triangular matrix multiply. BLAS Level 2; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-3a039ce3ced5d49a`; source: <https://www.netlib.org/slatec/lin/ctbmv.f>; native symbol: `ctbmv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `TRANS`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `DIAG`: Input one-byte CHARACTER flag selecting unit or non-unit diagonal treatment; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `K`: Input inner or band dimension used by the selected operation.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `X`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/ctbmv.md"))]
pub use crate::generated::blas::ctbmv;
// raw-api-routine: CTBSV
/// Original SLATEC routine `CTBSV`.
/// Solves a triangular matrix equation in-place in the right-hand-side storage.
/// Mathematical operation: triangular solve. BLAS Level 2; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-9276b968e8b424f5`; source: <https://www.netlib.org/slatec/lin/ctbsv.f>; native symbol: `ctbsv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `TRANS`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `DIAG`: Input one-byte CHARACTER flag selecting unit or non-unit diagonal treatment; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `K`: Input inner or band dimension used by the selected operation.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `X`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/ctbsv.md"))]
pub use crate::generated::blas::ctbsv;
// raw-api-routine: CTPMV
/// Original SLATEC routine `CTPMV`.
/// Multiplies a matrix or vector by a selected triangular matrix in-place.
/// Mathematical operation: triangular matrix multiply. BLAS Level 2; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-eb542c39fe12cc09`; source: <https://www.netlib.org/slatec/lin/ctpmv.f>; native symbol: `ctpmv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `TRANS`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `DIAG`: Input one-byte CHARACTER flag selecting unit or non-unit diagonal treatment; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `AP`: Packed symmetric, Hermitian, or triangular matrix storage. It is read or updated according to the selected operation and must contain the selected packed triangle.
/// - `X`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/ctpmv.md"))]
pub use crate::generated::blas::ctpmv;
// raw-api-routine: CTPSV
/// Original SLATEC routine `CTPSV`.
/// Solves a triangular matrix equation in-place in the right-hand-side storage.
/// Mathematical operation: triangular solve. BLAS Level 2; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-e025bbe82d5acb4e`; source: <https://www.netlib.org/slatec/lin/ctpsv.f>; native symbol: `ctpsv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `TRANS`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `DIAG`: Input one-byte CHARACTER flag selecting unit or non-unit diagonal treatment; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `AP`: Packed symmetric, Hermitian, or triangular matrix storage. It is read or updated according to the selected operation and must contain the selected packed triangle.
/// - `X`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/ctpsv.md"))]
pub use crate::generated::blas::ctpsv;
// raw-api-routine: CTRMV
/// Original SLATEC routine `CTRMV`.
/// Multiplies a matrix or vector by a selected triangular matrix in-place.
/// Mathematical operation: triangular matrix multiply. BLAS Level 2; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-5752b16f9c1df3d3`; source: <https://www.netlib.org/slatec/lin/ctrmv.f>; native symbol: `ctrmv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `TRANS`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `DIAG`: Input one-byte CHARACTER flag selecting unit or non-unit diagonal treatment; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `X`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/ctrmv.md"))]
pub use crate::generated::blas::ctrmv;
// raw-api-routine: CTRSV
/// Original SLATEC routine `CTRSV`.
/// Solves a triangular matrix equation in-place in the right-hand-side storage.
/// Mathematical operation: triangular solve. BLAS Level 2; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-f18c539a9796f458`; source: <https://www.netlib.org/slatec/lin/ctrsv.f>; native symbol: `ctrsv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `TRANS`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `DIAG`: Input one-byte CHARACTER flag selecting unit or non-unit diagonal treatment; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `X`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/ctrsv.md"))]
pub use crate::generated::blas::ctrsv;
// raw-api-routine: DGBMV
/// Original SLATEC routine `DGBMV`.
/// Executes the selected BLAS-family general band matrix-vector multiply operation.
/// Mathematical operation: general band matrix-vector multiply. BLAS Level 2; scalar profile: `f64`.
/// Selected provider: `full-provider-143929c1dbdfa7eb`; source: <https://www.netlib.org/slatec/lin/dgbmv.f>; native symbol: `dgbmv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `TRANS`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `M`: Input row count. Matrix leading dimensions and operand storage must be valid for this selected dimension.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `KL`: Input number of stored sub- or super-diagonals in general band storage.
/// - `KU`: Input number of stored sub- or super-diagonals in general band storage.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `BETA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `Y`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dgbmv.md"))]
pub use crate::generated::blas::dgbmv;
// raw-api-routine: DGEMV
/// Original SLATEC routine `DGEMV`.
/// Computes `Y <- alpha * op(A) * X + beta * Y` in column-major storage.
/// Mathematical operation: general matrix-vector multiply. BLAS Level 2; scalar profile: `f64`.
/// Selected provider: `full-provider-892b90618050293c`; source: <https://www.netlib.org/slatec/lin/dgemv.f>; native symbol: `dgemv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `TRANS`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `M`: Input row count. Matrix leading dimensions and operand storage must be valid for this selected dimension.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `BETA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `Y`: output or in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dgemv.md"))]
pub use crate::generated::blas::dgemv;
// raw-api-routine: DGER
/// Original SLATEC routine `DGER`.
/// Executes the selected BLAS-family rank-one matrix update operation.
/// Mathematical operation: rank-one matrix update. BLAS Level 2; scalar profile: `f64`.
/// Selected provider: `full-provider-9159dc7c314e7342`; source: <https://www.netlib.org/slatec/lin/dger.f>; native symbol: `dger_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `M`: Input row count. Matrix leading dimensions and operand storage must be valid for this selected dimension.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `Y`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `A`: In/out column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dger.md"))]
pub use crate::generated::blas::dger;
// raw-api-routine: DSBMV
/// Original SLATEC routine `DSBMV`.
/// Executes the selected BLAS-family symmetric or Hermitian matrix-vector multiply operation.
/// Mathematical operation: symmetric or Hermitian matrix-vector multiply. BLAS Level 2; scalar profile: `f64`.
/// Selected provider: `full-provider-8f071073bd2af04a`; source: <https://www.netlib.org/slatec/lin/dsbmv.f>; native symbol: `dsbmv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `K`: Input inner or band dimension used by the selected operation.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `BETA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `Y`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dsbmv.md"))]
pub use crate::generated::blas::dsbmv;
// raw-api-routine: DSPMV
/// Original SLATEC routine `DSPMV`.
/// Executes the selected BLAS-family symmetric or Hermitian matrix-vector multiply operation.
/// Mathematical operation: symmetric or Hermitian matrix-vector multiply. BLAS Level 2; scalar profile: `f64`.
/// Selected provider: `full-provider-65b1993f01d8a721`; source: <https://www.netlib.org/slatec/lin/dspmv.f>; native symbol: `dspmv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `AP`: Packed symmetric, Hermitian, or triangular matrix storage. It is read or updated according to the selected operation and must contain the selected packed triangle.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `BETA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `Y`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dspmv.md"))]
pub use crate::generated::blas::dspmv;
// raw-api-routine: DSPR
/// Original SLATEC routine `DSPR`.
/// Executes the selected BLAS-family symmetric or Hermitian rank-one update operation.
/// Mathematical operation: symmetric or Hermitian rank-one update. BLAS Level 2; scalar profile: `f64`.
/// Selected provider: `full-provider-8d99a8a869d4e52b`; source: <https://www.netlib.org/slatec/lin/dspr.f>; native symbol: `dspr_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `AP`: Packed symmetric, Hermitian, or triangular matrix storage. It is read or updated according to the selected operation and must contain the selected packed triangle.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dspr.md"))]
pub use crate::generated::blas::dspr;
// raw-api-routine: DSPR2
/// Original SLATEC routine `DSPR2`.
/// Executes the selected BLAS-family selected BLAS helper operation.
/// Mathematical operation: selected BLAS helper. BLAS Level 2; scalar profile: `f64`.
/// Selected provider: `full-provider-8c762f0f34843131`; source: <https://www.netlib.org/slatec/lin/dspr2.f>; native symbol: `dspr2_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `Y`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `AP`: Packed symmetric, Hermitian, or triangular matrix storage. It is read or updated according to the selected operation and must contain the selected packed triangle.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dspr2.md"))]
pub use crate::generated::blas::dspr2;
// raw-api-routine: DSYMV
/// Original SLATEC routine `DSYMV`.
/// Executes the selected BLAS-family symmetric or Hermitian matrix-vector multiply operation.
/// Mathematical operation: symmetric or Hermitian matrix-vector multiply. BLAS Level 2; scalar profile: `f64`.
/// Selected provider: `full-provider-537811ea4507de9d`; source: <https://www.netlib.org/slatec/lin/dsymv.f>; native symbol: `dsymv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `BETA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `Y`: output or in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dsymv.md"))]
pub use crate::generated::blas::dsymv;
// raw-api-routine: DSYR
/// Original SLATEC routine `DSYR`.
/// Executes the selected BLAS-family symmetric or Hermitian rank-one update operation.
/// Mathematical operation: symmetric or Hermitian rank-one update. BLAS Level 2; scalar profile: `f64`.
/// Selected provider: `full-provider-8628991f51121973`; source: <https://www.netlib.org/slatec/lin/dsyr.f>; native symbol: `dsyr_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `A`: In/out column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dsyr.md"))]
pub use crate::generated::blas::dsyr;
// raw-api-routine: DSYR2
/// Original SLATEC routine `DSYR2`.
/// Executes the selected BLAS-family symmetric or Hermitian rank-two update operation.
/// Mathematical operation: symmetric or Hermitian rank-two update. BLAS Level 2; scalar profile: `f64`.
/// Selected provider: `full-provider-f6d177f274fabe22`; source: <https://www.netlib.org/slatec/lin/dsyr2.f>; native symbol: `dsyr2_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `Y`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `A`: In/out column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dsyr2.md"))]
pub use crate::generated::blas::dsyr2;
// raw-api-routine: DTBMV
/// Original SLATEC routine `DTBMV`.
/// Multiplies a matrix or vector by a selected triangular matrix in-place.
/// Mathematical operation: triangular matrix multiply. BLAS Level 2; scalar profile: `f64`.
/// Selected provider: `full-provider-8303240383888897`; source: <https://www.netlib.org/slatec/lin/dtbmv.f>; native symbol: `dtbmv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `TRANS`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `DIAG`: Input one-byte CHARACTER flag selecting unit or non-unit diagonal treatment; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `K`: Input inner or band dimension used by the selected operation.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `X`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dtbmv.md"))]
pub use crate::generated::blas::dtbmv;
// raw-api-routine: DTBSV
/// Original SLATEC routine `DTBSV`.
/// Solves a triangular matrix equation in-place in the right-hand-side storage.
/// Mathematical operation: triangular solve. BLAS Level 2; scalar profile: `f64`.
/// Selected provider: `full-provider-d58a0228f3c665b9`; source: <https://www.netlib.org/slatec/lin/dtbsv.f>; native symbol: `dtbsv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `TRANS`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `DIAG`: Input one-byte CHARACTER flag selecting unit or non-unit diagonal treatment; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `K`: Input inner or band dimension used by the selected operation.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `X`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dtbsv.md"))]
pub use crate::generated::blas::dtbsv;
// raw-api-routine: DTPMV
/// Original SLATEC routine `DTPMV`.
/// Multiplies a matrix or vector by a selected triangular matrix in-place.
/// Mathematical operation: triangular matrix multiply. BLAS Level 2; scalar profile: `f64`.
/// Selected provider: `full-provider-59327c0c519db899`; source: <https://www.netlib.org/slatec/lin/dtpmv.f>; native symbol: `dtpmv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `TRANS`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `DIAG`: Input one-byte CHARACTER flag selecting unit or non-unit diagonal treatment; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `AP`: Packed symmetric, Hermitian, or triangular matrix storage. It is read or updated according to the selected operation and must contain the selected packed triangle.
/// - `X`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dtpmv.md"))]
pub use crate::generated::blas::dtpmv;
// raw-api-routine: DTPSV
/// Original SLATEC routine `DTPSV`.
/// Solves a triangular matrix equation in-place in the right-hand-side storage.
/// Mathematical operation: triangular solve. BLAS Level 2; scalar profile: `f64`.
/// Selected provider: `full-provider-71f1e36cff931719`; source: <https://www.netlib.org/slatec/lin/dtpsv.f>; native symbol: `dtpsv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `TRANS`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `DIAG`: Input one-byte CHARACTER flag selecting unit or non-unit diagonal treatment; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `AP`: Packed symmetric, Hermitian, or triangular matrix storage. It is read or updated according to the selected operation and must contain the selected packed triangle.
/// - `X`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dtpsv.md"))]
pub use crate::generated::blas::dtpsv;
// raw-api-routine: DTRMV
/// Original SLATEC routine `DTRMV`.
/// Multiplies a matrix or vector by a selected triangular matrix in-place.
/// Mathematical operation: triangular matrix multiply. BLAS Level 2; scalar profile: `f64`.
/// Selected provider: `full-provider-8affef5b867e516b`; source: <https://www.netlib.org/slatec/lin/dtrmv.f>; native symbol: `dtrmv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `TRANS`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `DIAG`: Input one-byte CHARACTER flag selecting unit or non-unit diagonal treatment; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `X`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dtrmv.md"))]
pub use crate::generated::blas::dtrmv;
// raw-api-routine: DTRSV
/// Original SLATEC routine `DTRSV`.
/// Solves a triangular matrix equation in-place in the right-hand-side storage.
/// Mathematical operation: triangular solve. BLAS Level 2; scalar profile: `f64`.
/// Selected provider: `full-provider-2cf8628c34f7bbf7`; source: <https://www.netlib.org/slatec/lin/dtrsv.f>; native symbol: `dtrsv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `TRANS`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `DIAG`: Input one-byte CHARACTER flag selecting unit or non-unit diagonal treatment; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `X`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dtrsv.md"))]
pub use crate::generated::blas::dtrsv;
// raw-api-routine: SGBMV
/// Original SLATEC routine `SGBMV`.
/// Executes the selected BLAS-family general band matrix-vector multiply operation.
/// Mathematical operation: general band matrix-vector multiply. BLAS Level 2; scalar profile: `f32`.
/// Selected provider: `full-provider-d4e4fd5fe5e771b9`; source: <https://www.netlib.org/slatec/lin/sgbmv.f>; native symbol: `sgbmv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `TRANS`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `M`: Input row count. Matrix leading dimensions and operand storage must be valid for this selected dimension.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `KL`: Input number of stored sub- or super-diagonals in general band storage.
/// - `KU`: Input number of stored sub- or super-diagonals in general band storage.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `BETA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `Y`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/sgbmv.md"))]
pub use crate::generated::blas::sgbmv;
// raw-api-routine: SGEMV
/// Original SLATEC routine `SGEMV`.
/// Computes `Y <- alpha * op(A) * X + beta * Y` in column-major storage.
/// Mathematical operation: general matrix-vector multiply. BLAS Level 2; scalar profile: `f32`.
/// Selected provider: `full-provider-c0f8341783facdb3`; source: <https://www.netlib.org/slatec/lin/sgemv.f>; native symbol: `sgemv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `TRANS`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `M`: Input row count. Matrix leading dimensions and operand storage must be valid for this selected dimension.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `BETA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `Y`: output or in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/sgemv.md"))]
pub use crate::generated::blas::sgemv;
// raw-api-routine: SGER
/// Original SLATEC routine `SGER`.
/// Executes the selected BLAS-family rank-one matrix update operation.
/// Mathematical operation: rank-one matrix update. BLAS Level 2; scalar profile: `f32`.
/// Selected provider: `full-provider-3a9e0b8565c6df78`; source: <https://www.netlib.org/slatec/lin/sger.f>; native symbol: `sger_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `M`: Input row count. Matrix leading dimensions and operand storage must be valid for this selected dimension.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `Y`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `A`: In/out column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/sger.md"))]
pub use crate::generated::blas::sger;
// raw-api-routine: SSBMV
/// Original SLATEC routine `SSBMV`.
/// Executes the selected BLAS-family symmetric or Hermitian matrix-vector multiply operation.
/// Mathematical operation: symmetric or Hermitian matrix-vector multiply. BLAS Level 2; scalar profile: `f32`.
/// Selected provider: `full-provider-a1227de9862daad4`; source: <https://www.netlib.org/slatec/lin/ssbmv.f>; native symbol: `ssbmv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `K`: Input inner or band dimension used by the selected operation.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `BETA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `Y`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/ssbmv.md"))]
pub use crate::generated::blas::ssbmv;
// raw-api-routine: SSPMV
/// Original SLATEC routine `SSPMV`.
/// Executes the selected BLAS-family symmetric or Hermitian matrix-vector multiply operation.
/// Mathematical operation: symmetric or Hermitian matrix-vector multiply. BLAS Level 2; scalar profile: `f32`.
/// Selected provider: `full-provider-11b315f490eeb90f`; source: <https://www.netlib.org/slatec/lin/sspmv.f>; native symbol: `sspmv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `AP`: Packed symmetric, Hermitian, or triangular matrix storage. It is read or updated according to the selected operation and must contain the selected packed triangle.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `BETA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `Y`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/sspmv.md"))]
pub use crate::generated::blas::sspmv;
// raw-api-routine: SSPR
/// Original SLATEC routine `SSPR`.
/// Executes the selected BLAS-family symmetric or Hermitian rank-one update operation.
/// Mathematical operation: symmetric or Hermitian rank-one update. BLAS Level 2; scalar profile: `f32`.
/// Selected provider: `full-provider-5b31f84d09b28a8c`; source: <https://www.netlib.org/slatec/lin/sspr.f>; native symbol: `sspr_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `AP`: Packed symmetric, Hermitian, or triangular matrix storage. It is read or updated according to the selected operation and must contain the selected packed triangle.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/sspr.md"))]
pub use crate::generated::blas::sspr;
// raw-api-routine: SSPR2
/// Original SLATEC routine `SSPR2`.
/// Executes the selected BLAS-family selected BLAS helper operation.
/// Mathematical operation: selected BLAS helper. BLAS Level 2; scalar profile: `f32`.
/// Selected provider: `full-provider-94496e89829acba5`; source: <https://www.netlib.org/slatec/lin/sspr2.f>; native symbol: `sspr2_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `Y`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `AP`: Packed symmetric, Hermitian, or triangular matrix storage. It is read or updated according to the selected operation and must contain the selected packed triangle.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/sspr2.md"))]
pub use crate::generated::blas::sspr2;
// raw-api-routine: SSYMV
/// Original SLATEC routine `SSYMV`.
/// Executes the selected BLAS-family symmetric or Hermitian matrix-vector multiply operation.
/// Mathematical operation: symmetric or Hermitian matrix-vector multiply. BLAS Level 2; scalar profile: `f32`.
/// Selected provider: `full-provider-cfda14a30ad21354`; source: <https://www.netlib.org/slatec/lin/ssymv.f>; native symbol: `ssymv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `BETA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `Y`: output or in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/ssymv.md"))]
pub use crate::generated::blas::ssymv;
// raw-api-routine: SSYR
/// Original SLATEC routine `SSYR`.
/// Executes the selected BLAS-family symmetric or Hermitian rank-one update operation.
/// Mathematical operation: symmetric or Hermitian rank-one update. BLAS Level 2; scalar profile: `f32`.
/// Selected provider: `full-provider-8f2eb997304a6a52`; source: <https://www.netlib.org/slatec/lin/ssyr.f>; native symbol: `ssyr_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `A`: In/out column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/ssyr.md"))]
pub use crate::generated::blas::ssyr;
// raw-api-routine: SSYR2
/// Original SLATEC routine `SSYR2`.
/// Executes the selected BLAS-family symmetric or Hermitian rank-two update operation.
/// Mathematical operation: symmetric or Hermitian rank-two update. BLAS Level 2; scalar profile: `f32`.
/// Selected provider: `full-provider-d67df259cdde2894`; source: <https://www.netlib.org/slatec/lin/ssyr2.f>; native symbol: `ssyr2_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `X`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `Y`: input vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCY` elements. The native routine retains no pointer.
/// - `INCY`: Input vector storage increment for Y. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
/// - `A`: In/out column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/ssyr2.md"))]
pub use crate::generated::blas::ssyr2;
// raw-api-routine: STBMV
/// Original SLATEC routine `STBMV`.
/// Multiplies a matrix or vector by a selected triangular matrix in-place.
/// Mathematical operation: triangular matrix multiply. BLAS Level 2; scalar profile: `f32`.
/// Selected provider: `full-provider-4ba1f66b5173ea76`; source: <https://www.netlib.org/slatec/lin/stbmv.f>; native symbol: `stbmv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `TRANS`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `DIAG`: Input one-byte CHARACTER flag selecting unit or non-unit diagonal treatment; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `K`: Input inner or band dimension used by the selected operation.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `X`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/stbmv.md"))]
pub use crate::generated::blas::stbmv;
// raw-api-routine: STBSV
/// Original SLATEC routine `STBSV`.
/// Solves a triangular matrix equation in-place in the right-hand-side storage.
/// Mathematical operation: triangular solve. BLAS Level 2; scalar profile: `f32`.
/// Selected provider: `full-provider-eeb6e4a21f25d8e9`; source: <https://www.netlib.org/slatec/lin/stbsv.f>; native symbol: `stbsv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `TRANS`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `DIAG`: Input one-byte CHARACTER flag selecting unit or non-unit diagonal treatment; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `K`: Input inner or band dimension used by the selected operation.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `X`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/stbsv.md"))]
pub use crate::generated::blas::stbsv;
// raw-api-routine: STPMV
/// Original SLATEC routine `STPMV`.
/// Multiplies a matrix or vector by a selected triangular matrix in-place.
/// Mathematical operation: triangular matrix multiply. BLAS Level 2; scalar profile: `f32`.
/// Selected provider: `full-provider-65891856028355a3`; source: <https://www.netlib.org/slatec/lin/stpmv.f>; native symbol: `stpmv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `TRANS`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `DIAG`: Input one-byte CHARACTER flag selecting unit or non-unit diagonal treatment; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `AP`: Packed symmetric, Hermitian, or triangular matrix storage. It is read or updated according to the selected operation and must contain the selected packed triangle.
/// - `X`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/stpmv.md"))]
pub use crate::generated::blas::stpmv;
// raw-api-routine: STPSV
/// Original SLATEC routine `STPSV`.
/// Solves a triangular matrix equation in-place in the right-hand-side storage.
/// Mathematical operation: triangular solve. BLAS Level 2; scalar profile: `f32`.
/// Selected provider: `full-provider-2ff88e804e1d3744`; source: <https://www.netlib.org/slatec/lin/stpsv.f>; native symbol: `stpsv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `TRANS`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `DIAG`: Input one-byte CHARACTER flag selecting unit or non-unit diagonal treatment; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `AP`: Packed symmetric, Hermitian, or triangular matrix storage. It is read or updated according to the selected operation and must contain the selected packed triangle.
/// - `X`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/stpsv.md"))]
pub use crate::generated::blas::stpsv;
// raw-api-routine: STRMV
/// Original SLATEC routine `STRMV`.
/// Multiplies a matrix or vector by a selected triangular matrix in-place.
/// Mathematical operation: triangular matrix multiply. BLAS Level 2; scalar profile: `f32`.
/// Selected provider: `full-provider-ecd3c21d1e5ef169`; source: <https://www.netlib.org/slatec/lin/strmv.f>; native symbol: `strmv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `TRANS`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `DIAG`: Input one-byte CHARACTER flag selecting unit or non-unit diagonal treatment; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `X`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/strmv.md"))]
pub use crate::generated::blas::strmv;
// raw-api-routine: STRSV
/// Original SLATEC routine `STRSV`.
/// Solves a triangular matrix equation in-place in the right-hand-side storage.
/// Mathematical operation: triangular solve. BLAS Level 2; scalar profile: `f32`.
/// Selected provider: `full-provider-43b388fe1db47164`; source: <https://www.netlib.org/slatec/lin/strsv.f>; native symbol: `strsv_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `TRANS`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `DIAG`: Input one-byte CHARACTER flag selecting unit or non-unit diagonal treatment; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `X`: in/out vector operand. For `N > 0`, make the complete source-defined strided extent accessible from the selected Fortran starting position; for a positive increment this is `1 + (N - 1) * INCX` elements. The native routine retains no pointer.
/// - `INCX`: Input vector storage increment for X. Its permitted sign and traversal are defined by this routine's selected source prologue; this raw interface does not normalize zero or negative increments.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/strsv.md"))]
pub use crate::generated::blas::strsv;
}
/// Reviewed public BLAS Level 3 raw routines.
#[cfg(any(feature = "blas-level3", feature = "raw-family-blas-level3"))]
pub mod level3 {
// raw-api-routine: CGEMM
/// Original SLATEC routine `CGEMM`.
/// Computes `C <- alpha * op(A) * op(B) + beta * C` in column-major storage.
/// Mathematical operation: general matrix-matrix multiply. BLAS Level 3; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-a6bffdae5d880dea`; source: <https://www.netlib.org/slatec/lin/cgemm.f>; native symbol: `cgemm_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `TRANSA`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `TRANSB`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `M`: Input row count. Matrix leading dimensions and operand storage must be valid for this selected dimension.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `K`: Input inner or band dimension used by the selected operation.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `B`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDB`: Input leading dimension for the column-major B operand. It must meet the selected source's dimension rule for the active flags.
/// - `BETA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `C`: In/out column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDC`: Input leading dimension for the column-major C operand. It must meet the selected source's dimension rule for the active flags.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/cgemm.md"))]
pub use crate::generated::blas::cgemm;
// raw-api-routine: CHEMM
/// Original SLATEC routine `CHEMM`.
/// Executes the selected BLAS-family symmetric or Hermitian matrix multiply operation.
/// Mathematical operation: symmetric or Hermitian matrix multiply. BLAS Level 3; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-46159cbb087ce9d5`; source: <https://www.netlib.org/slatec/lin/chemm.f>; native symbol: `chemm_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `SIDE`: Input one-byte CHARACTER flag selecting whether the matrix operand acts on the left or right; pass its trailing hidden length as `1`.
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `M`: Input row count. Matrix leading dimensions and operand storage must be valid for this selected dimension.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `B`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDB`: Input leading dimension for the column-major B operand. It must meet the selected source's dimension rule for the active flags.
/// - `BETA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `C`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDC`: Input leading dimension for the column-major C operand. It must meet the selected source's dimension rule for the active flags.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/chemm.md"))]
pub use crate::generated::blas::chemm;
// raw-api-routine: CHER2K
/// Original SLATEC routine `CHER2K`.
/// Executes the selected BLAS-family symmetric or Hermitian rank-2k update operation.
/// Mathematical operation: symmetric or Hermitian rank-2k update. BLAS Level 3; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-9278dcd935cfe641`; source: <https://www.netlib.org/slatec/lin/cher2k.f>; native symbol: `cher2k_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `TRANS`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `K`: Input inner or band dimension used by the selected operation.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `B`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDB`: Input leading dimension for the column-major B operand. It must meet the selected source's dimension rule for the active flags.
/// - `BETA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `C`: In/out column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDC`: Input leading dimension for the column-major C operand. It must meet the selected source's dimension rule for the active flags.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/cher2k.md"))]
pub use crate::generated::blas::cher2k;
// raw-api-routine: CHERK
/// Original SLATEC routine `CHERK`.
/// Executes the selected BLAS-family symmetric or Hermitian rank-k update operation.
/// Mathematical operation: symmetric or Hermitian rank-k update. BLAS Level 3; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-ceef25931bce6395`; source: <https://www.netlib.org/slatec/lin/cherk.f>; native symbol: `cherk_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `TRANS`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `K`: Input inner or band dimension used by the selected operation.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `BETA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `C`: In/out column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDC`: Input leading dimension for the column-major C operand. It must meet the selected source's dimension rule for the active flags.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/cherk.md"))]
pub use crate::generated::blas::cherk;
// raw-api-routine: CSYMM
/// Original SLATEC routine `CSYMM`.
/// Executes the selected BLAS-family symmetric or Hermitian matrix multiply operation.
/// Mathematical operation: symmetric or Hermitian matrix multiply. BLAS Level 3; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-c0baad22c187ee09`; source: <https://www.netlib.org/slatec/lin/csymm.f>; native symbol: `csymm_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `SIDE`: Input one-byte CHARACTER flag selecting whether the matrix operand acts on the left or right; pass its trailing hidden length as `1`.
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `M`: Input row count. Matrix leading dimensions and operand storage must be valid for this selected dimension.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `B`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDB`: Input leading dimension for the column-major B operand. It must meet the selected source's dimension rule for the active flags.
/// - `BETA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `C`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDC`: Input leading dimension for the column-major C operand. It must meet the selected source's dimension rule for the active flags.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/csymm.md"))]
pub use crate::generated::blas::csymm;
// raw-api-routine: CSYR2K
/// Original SLATEC routine `CSYR2K`.
/// Executes the selected BLAS-family symmetric or Hermitian rank-2k update operation.
/// Mathematical operation: symmetric or Hermitian rank-2k update. BLAS Level 3; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-81294e9faf716e01`; source: <https://www.netlib.org/slatec/lin/csyr2k.f>; native symbol: `csyr2k_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `TRANS`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `K`: Input inner or band dimension used by the selected operation.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `B`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDB`: Input leading dimension for the column-major B operand. It must meet the selected source's dimension rule for the active flags.
/// - `BETA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `C`: In/out column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDC`: Input leading dimension for the column-major C operand. It must meet the selected source's dimension rule for the active flags.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/csyr2k.md"))]
pub use crate::generated::blas::csyr2k;
// raw-api-routine: CSYRK
/// Original SLATEC routine `CSYRK`.
/// Executes the selected BLAS-family symmetric or Hermitian rank-k update operation.
/// Mathematical operation: symmetric or Hermitian rank-k update. BLAS Level 3; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-623d0832b9cc5fb2`; source: <https://www.netlib.org/slatec/lin/csyrk.f>; native symbol: `csyrk_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `TRANS`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `K`: Input inner or band dimension used by the selected operation.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `BETA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `C`: In/out column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDC`: Input leading dimension for the column-major C operand. It must meet the selected source's dimension rule for the active flags.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/csyrk.md"))]
pub use crate::generated::blas::csyrk;
// raw-api-routine: CTRMM
/// Original SLATEC routine `CTRMM`.
/// Multiplies a matrix or vector by a selected triangular matrix in-place.
/// Mathematical operation: triangular matrix multiply. BLAS Level 3; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-d8bde96154a88836`; source: <https://www.netlib.org/slatec/lin/ctrmm.f>; native symbol: `ctrmm_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `SIDE`: Input one-byte CHARACTER flag selecting whether the matrix operand acts on the left or right; pass its trailing hidden length as `1`.
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `TRANSA`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `DIAG`: Input one-byte CHARACTER flag selecting unit or non-unit diagonal treatment; pass its trailing hidden length as `1`.
/// - `M`: Input row count. Matrix leading dimensions and operand storage must be valid for this selected dimension.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `B`: In/out column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDB`: Input leading dimension for the column-major B operand. It must meet the selected source's dimension rule for the active flags.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/ctrmm.md"))]
pub use crate::generated::blas::ctrmm;
// raw-api-routine: CTRSM
/// Original SLATEC routine `CTRSM`.
/// Solves a triangular matrix equation in-place in the right-hand-side storage.
/// Mathematical operation: triangular solve. BLAS Level 3; scalar profile: `complex_f32`.
/// Selected provider: `full-provider-e6ef67d633aaef2b`; source: <https://www.netlib.org/slatec/lin/ctrsm.f>; native symbol: `ctrsm_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `SIDE`: Input one-byte CHARACTER flag selecting whether the matrix operand acts on the left or right; pass its trailing hidden length as `1`.
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `TRANSA`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `DIAG`: Input one-byte CHARACTER flag selecting unit or non-unit diagonal treatment; pass its trailing hidden length as `1`.
/// - `M`: Input row count. Matrix leading dimensions and operand storage must be valid for this selected dimension.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `B`: In/out column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDB`: Input leading dimension for the column-major B operand. It must meet the selected source's dimension rule for the active flags.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/ctrsm.md"))]
pub use crate::generated::blas::ctrsm;
// raw-api-routine: DGEMM
/// Original SLATEC routine `DGEMM`.
/// Computes `C <- alpha * op(A) * op(B) + beta * C` in column-major storage.
/// Mathematical operation: general matrix-matrix multiply. BLAS Level 3; scalar profile: `f64`.
/// Selected provider: `full-provider-8304816992104475`; source: <https://www.netlib.org/slatec/lin/dgemm.f>; native symbol: `dgemm_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `TRANSA`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `TRANSB`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `M`: Input row count. Matrix leading dimensions and operand storage must be valid for this selected dimension.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `K`: Input inner or band dimension used by the selected operation.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `B`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDB`: Input leading dimension for the column-major B operand. It must meet the selected source's dimension rule for the active flags.
/// - `BETA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `C`: In/out column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDC`: Input leading dimension for the column-major C operand. It must meet the selected source's dimension rule for the active flags.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dgemm.md"))]
pub use crate::generated::blas::dgemm;
// raw-api-routine: DSYMM
/// Original SLATEC routine `DSYMM`.
/// Executes the selected BLAS-family symmetric or Hermitian matrix multiply operation.
/// Mathematical operation: symmetric or Hermitian matrix multiply. BLAS Level 3; scalar profile: `f64`.
/// Selected provider: `full-provider-eb47ba3c479da5e7`; source: <https://www.netlib.org/slatec/lin/dsymm.f>; native symbol: `dsymm_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `SIDE`: Input one-byte CHARACTER flag selecting whether the matrix operand acts on the left or right; pass its trailing hidden length as `1`.
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `M`: Input row count. Matrix leading dimensions and operand storage must be valid for this selected dimension.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `B`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDB`: Input leading dimension for the column-major B operand. It must meet the selected source's dimension rule for the active flags.
/// - `BETA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `C`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDC`: Input leading dimension for the column-major C operand. It must meet the selected source's dimension rule for the active flags.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dsymm.md"))]
pub use crate::generated::blas::dsymm;
// raw-api-routine: DSYR2K
/// Original SLATEC routine `DSYR2K`.
/// Executes the selected BLAS-family symmetric or Hermitian rank-2k update operation.
/// Mathematical operation: symmetric or Hermitian rank-2k update. BLAS Level 3; scalar profile: `f64`.
/// Selected provider: `full-provider-ed171d14219a17c3`; source: <https://www.netlib.org/slatec/lin/dsyr2k.f>; native symbol: `dsyr2k_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `TRANS`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `K`: Input inner or band dimension used by the selected operation.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `B`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDB`: Input leading dimension for the column-major B operand. It must meet the selected source's dimension rule for the active flags.
/// - `BETA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `C`: In/out column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDC`: Input leading dimension for the column-major C operand. It must meet the selected source's dimension rule for the active flags.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dsyr2k.md"))]
pub use crate::generated::blas::dsyr2k;
// raw-api-routine: DSYRK
/// Original SLATEC routine `DSYRK`.
/// Executes the selected BLAS-family symmetric or Hermitian rank-k update operation.
/// Mathematical operation: symmetric or Hermitian rank-k update. BLAS Level 3; scalar profile: `f64`.
/// Selected provider: `full-provider-49015c300ceadad3`; source: <https://www.netlib.org/slatec/lin/dsyrk.f>; native symbol: `dsyrk_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `TRANS`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `K`: Input inner or band dimension used by the selected operation.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `BETA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `C`: In/out column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDC`: Input leading dimension for the column-major C operand. It must meet the selected source's dimension rule for the active flags.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dsyrk.md"))]
pub use crate::generated::blas::dsyrk;
// raw-api-routine: DTRMM
/// Original SLATEC routine `DTRMM`.
/// Multiplies a matrix or vector by a selected triangular matrix in-place.
/// Mathematical operation: triangular matrix multiply. BLAS Level 3; scalar profile: `f64`.
/// Selected provider: `full-provider-e30eb52568bab4c2`; source: <https://www.netlib.org/slatec/lin/dtrmm.f>; native symbol: `dtrmm_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `SIDE`: Input one-byte CHARACTER flag selecting whether the matrix operand acts on the left or right; pass its trailing hidden length as `1`.
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `TRANSA`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `DIAG`: Input one-byte CHARACTER flag selecting unit or non-unit diagonal treatment; pass its trailing hidden length as `1`.
/// - `M`: Input row count. Matrix leading dimensions and operand storage must be valid for this selected dimension.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `B`: In/out column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDB`: Input leading dimension for the column-major B operand. It must meet the selected source's dimension rule for the active flags.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dtrmm.md"))]
pub use crate::generated::blas::dtrmm;
// raw-api-routine: DTRSM
/// Original SLATEC routine `DTRSM`.
/// Solves a triangular matrix equation in-place in the right-hand-side storage.
/// Mathematical operation: triangular solve. BLAS Level 3; scalar profile: `f64`.
/// Selected provider: `full-provider-db08cd690ac8d4b3`; source: <https://www.netlib.org/slatec/lin/dtrsm.f>; native symbol: `dtrsm_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `SIDE`: Input one-byte CHARACTER flag selecting whether the matrix operand acts on the left or right; pass its trailing hidden length as `1`.
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `TRANSA`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `DIAG`: Input one-byte CHARACTER flag selecting unit or non-unit diagonal treatment; pass its trailing hidden length as `1`.
/// - `M`: Input row count. Matrix leading dimensions and operand storage must be valid for this selected dimension.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `B`: In/out column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDB`: Input leading dimension for the column-major B operand. It must meet the selected source's dimension rule for the active flags.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/dtrsm.md"))]
pub use crate::generated::blas::dtrsm;
// raw-api-routine: SGEMM
/// Original SLATEC routine `SGEMM`.
/// Computes `C <- alpha * op(A) * op(B) + beta * C` in column-major storage.
/// Mathematical operation: general matrix-matrix multiply. BLAS Level 3; scalar profile: `f32`.
/// Selected provider: `full-provider-a5a00e614f86f82e`; source: <https://www.netlib.org/slatec/lin/sgemm.f>; native symbol: `sgemm_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `TRANSA`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `TRANSB`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `M`: Input row count. Matrix leading dimensions and operand storage must be valid for this selected dimension.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `K`: Input inner or band dimension used by the selected operation.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `B`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDB`: Input leading dimension for the column-major B operand. It must meet the selected source's dimension rule for the active flags.
/// - `BETA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `C`: In/out column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDC`: Input leading dimension for the column-major C operand. It must meet the selected source's dimension rule for the active flags.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/sgemm.md"))]
pub use crate::generated::blas::sgemm;
// raw-api-routine: SSYMM
/// Original SLATEC routine `SSYMM`.
/// Executes the selected BLAS-family symmetric or Hermitian matrix multiply operation.
/// Mathematical operation: symmetric or Hermitian matrix multiply. BLAS Level 3; scalar profile: `f32`.
/// Selected provider: `full-provider-c0bbf0e6ac2e8f76`; source: <https://www.netlib.org/slatec/lin/ssymm.f>; native symbol: `ssymm_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `SIDE`: Input one-byte CHARACTER flag selecting whether the matrix operand acts on the left or right; pass its trailing hidden length as `1`.
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `M`: Input row count. Matrix leading dimensions and operand storage must be valid for this selected dimension.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `B`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDB`: Input leading dimension for the column-major B operand. It must meet the selected source's dimension rule for the active flags.
/// - `BETA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `C`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDC`: Input leading dimension for the column-major C operand. It must meet the selected source's dimension rule for the active flags.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/ssymm.md"))]
pub use crate::generated::blas::ssymm;
// raw-api-routine: SSYR2K
/// Original SLATEC routine `SSYR2K`.
/// Executes the selected BLAS-family symmetric or Hermitian rank-2k update operation.
/// Mathematical operation: symmetric or Hermitian rank-2k update. BLAS Level 3; scalar profile: `f32`.
/// Selected provider: `full-provider-8d12dec7a8e33d69`; source: <https://www.netlib.org/slatec/lin/ssyr2k.f>; native symbol: `ssyr2k_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `TRANS`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `K`: Input inner or band dimension used by the selected operation.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `B`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDB`: Input leading dimension for the column-major B operand. It must meet the selected source's dimension rule for the active flags.
/// - `BETA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `C`: In/out column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDC`: Input leading dimension for the column-major C operand. It must meet the selected source's dimension rule for the active flags.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/ssyr2k.md"))]
pub use crate::generated::blas::ssyr2k;
// raw-api-routine: SSYRK
/// Original SLATEC routine `SSYRK`.
/// Executes the selected BLAS-family symmetric or Hermitian rank-k update operation.
/// Mathematical operation: symmetric or Hermitian rank-k update. BLAS Level 3; scalar profile: `f32`.
/// Selected provider: `full-provider-7cc78c1abbf810dd`; source: <https://www.netlib.org/slatec/lin/ssyrk.f>; native symbol: `ssyrk_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `TRANS`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `K`: Input inner or band dimension used by the selected operation.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `BETA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `C`: In/out column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDC`: Input leading dimension for the column-major C operand. It must meet the selected source's dimension rule for the active flags.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/ssyrk.md"))]
pub use crate::generated::blas::ssyrk;
// raw-api-routine: STRMM
/// Original SLATEC routine `STRMM`.
/// Multiplies a matrix or vector by a selected triangular matrix in-place.
/// Mathematical operation: triangular matrix multiply. BLAS Level 3; scalar profile: `f32`.
/// Selected provider: `full-provider-bb823d3f343bc012`; source: <https://www.netlib.org/slatec/lin/strmm.f>; native symbol: `strmm_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `SIDE`: Input one-byte CHARACTER flag selecting whether the matrix operand acts on the left or right; pass its trailing hidden length as `1`.
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `TRANSA`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `DIAG`: Input one-byte CHARACTER flag selecting unit or non-unit diagonal treatment; pass its trailing hidden length as `1`.
/// - `M`: Input row count. Matrix leading dimensions and operand storage must be valid for this selected dimension.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `B`: In/out column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDB`: Input leading dimension for the column-major B operand. It must meet the selected source's dimension rule for the active flags.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/strmm.md"))]
pub use crate::generated::blas::strmm;
// raw-api-routine: STRSM
/// Original SLATEC routine `STRSM`.
/// Solves a triangular matrix equation in-place in the right-hand-side storage.
/// Mathematical operation: triangular solve. BLAS Level 3; scalar profile: `f32`.
/// Selected provider: `full-provider-b1c48855a1ea9bc8`; source: <https://www.netlib.org/slatec/lin/strsm.f>; native symbol: `strsm_`.
/// Supported ABI profile: `ffi-profile-gnu-mingw-x86_64` (GNU Fortran default INTEGER and trailing CHARACTER lengths).
///
/// # Arguments
/// - `SIDE`: Input one-byte CHARACTER flag selecting whether the matrix operand acts on the left or right; pass its trailing hidden length as `1`.
/// - `UPLO`: Input one-byte CHARACTER flag selecting the stored upper or lower triangle; pass its trailing hidden length as `1`.
/// - `TRANSA`: Input one-byte CHARACTER flag selecting no-transpose, transpose, or (for complex routines) conjugate-transpose as accepted by the selected source; pass its trailing hidden length as `1`.
/// - `DIAG`: Input one-byte CHARACTER flag selecting unit or non-unit diagonal treatment; pass its trailing hidden length as `1`.
/// - `M`: Input row count. Matrix leading dimensions and operand storage must be valid for this selected dimension.
/// - `N`: Input operation order or vector element count. The selected routine may quick-return when it is non-positive.
/// - `ALPHA`: Input scalar multiplier. It is read for the duration of the call and is not retained.
/// - `A`: Input column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDA`: Input leading dimension for the column-major A operand. It must meet the selected source's dimension rule for the active flags.
/// - `B`: In/out column-major matrix operand. Its leading dimension and accessible extent must satisfy the selected source for the active flags.
/// - `LDB`: Input leading dimension for the column-major B operand. It must meet the selected source's dimension rule for the active flags.
///
/// # Safety
/// All scalar pointers must be non-null and valid for the documented read or write access. Every vector and matrix pointer must describe contiguous Fortran column-major storage with the stated leading dimensions and strides. For a strided vector with `N > 0`, make the complete source-defined extent accessible; positive increments need at least `1 + (N - 1) * INC` elements from the selected starting element. Zero and negative increments are accepted only where the selected routine's prologue permits them; this raw interface never normalizes them. Do not pass overlapping mutable operands unless the selected source explicitly permits that overlap. The native routine retains no pointer after return. The raw API does not serialize calls; callers must account for the linked SLATEC runtime and any broader process-global state.
#[doc(inline)]
#[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/generated_docs/strsm.md"))]
pub use crate::generated::blas::strsm;
}