linear-srgb 0.6.8

Fast linear↔sRGB color space conversion with FMA acceleration and LUT support
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

//! Fused multiply-add abstraction with compile-time hardware detection.
//!
//! When FMA is available (x86 with FMA feature or ARM64 NEON), uses single-cycle
//! hardware FMA instructions. Otherwise falls back to separate multiply+add.

#[cfg(any(
    all(
        any(target_arch = "x86", target_arch = "x86_64"),
        target_feature = "fma"
    ),
    all(target_arch = "aarch64", target_feature = "neon")
))]
use num_traits::MulAdd;

/// Computes `acc + a * b` using FMA when available.
///
/// # Hardware Detection
/// - x86/x86_64 with FMA feature: uses `_mm_fmadd_*` intrinsics via `MulAdd`
/// - aarch64 with NEON: uses `vfma*` intrinsics via `MulAdd`
/// - Otherwise: falls back to `acc + a * b`
#[cfg(any(
    all(
        any(target_arch = "x86", target_arch = "x86_64"),
        target_feature = "fma"
    ),
    all(target_arch = "aarch64", target_feature = "neon")
))]
#[inline(always)]
pub fn mlaf<T: MulAdd<T, Output = T>>(acc: T, a: T, b: T) -> T {
    MulAdd::mul_add(a, b, acc)
}

/// Computes `acc + a * b` (fallback without hardware FMA).
#[cfg(not(any(
    all(
        any(target_arch = "x86", target_arch = "x86_64"),
        target_feature = "fma"
    ),
    all(target_arch = "aarch64", target_feature = "neon")
)))]
#[inline(always)]
pub fn mlaf<T: core::ops::Add<Output = T> + core::ops::Mul<Output = T>>(acc: T, a: T, b: T) -> T {
    acc + a * b
}

/// Computes `acc - a * b` using FMA when available.
#[cfg(any(
    all(
        any(target_arch = "x86", target_arch = "x86_64"),
        target_feature = "fma"
    ),
    all(target_arch = "aarch64", target_feature = "neon")
))]
#[inline(always)]
pub fn neg_mlaf<T: MulAdd<T, Output = T> + core::ops::Neg<Output = T>>(acc: T, a: T, b: T) -> T {
    mlaf(acc, a, -b)
}

/// Computes `acc - a * b` (fallback without hardware FMA).
#[cfg(not(any(
    all(
        any(target_arch = "x86", target_arch = "x86_64"),
        target_feature = "fma"
    ),
    all(target_arch = "aarch64", target_feature = "neon")
)))]
#[inline(always)]
pub fn neg_mlaf<
    T: core::ops::Add<Output = T> + core::ops::Mul<Output = T> + core::ops::Neg<Output = T>,
>(
    acc: T,
    a: T,
    b: T,
) -> T {
    acc + a * (-b)
}

/// Computes `a * b + c` (reordered FMA for ergonomics).
///
/// This matches the mathematical notation `a * b + c` more naturally.
#[inline(always)]
pub fn fmla<T>(a: T, b: T, c: T) -> T
where
    T: MlaCompatible,
{
    T::mla(c, a, b)
}

/// Trait for types that support MLA operations.
/// This abstracts over the cfg-dependent mlaf implementations.
pub trait MlaCompatible: Sized {
    fn mla(acc: Self, a: Self, b: Self) -> Self;
}

impl MlaCompatible for f32 {
    #[inline(always)]
    fn mla(acc: Self, a: Self, b: Self) -> Self {
        mlaf(acc, a, b)
    }
}

impl MlaCompatible for f64 {
    #[inline(always)]
    fn mla(acc: Self, a: Self, b: Self) -> Self {
        mlaf(acc, a, b)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_mlaf_f32() {
        let result = mlaf(1.0f32, 2.0f32, 3.0f32);
        assert_eq!(result, 7.0f32);
    }

    #[test]
    fn test_mlaf_f64() {
        let result = mlaf(1.0f64, 2.0f64, 3.0f64);
        assert_eq!(result, 7.0f64);
    }

    #[test]
    fn test_neg_mlaf_f32() {
        let result = neg_mlaf(10.0f32, 2.0f32, 3.0f32);
        assert_eq!(result, 4.0f32);
    }

    #[test]
    fn test_fmla_f32() {
        let result = fmla(2.0f32, 3.0f32, 1.0f32);
        assert_eq!(result, 7.0f32);
    }
}