simd_vector 0.1.0

SIMD vector types (Vec4, Vec8) for x86-64 in pure stable Rust — SSE4.1, AVX2, FMA3
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

# simd_vector

SIMD vector types for x86-64 in pure stable Rust.

- `Vec4` — 4×f32, SSE4.1 + FMA3
- `Vec8` — 8×f32, AVX2 + FMA3

## Features

- Arithmetic: `+`, `-`, `*`, `/` (vec×vec, vec×f32, f32×vec)
- `splat`, `abs`, `neg`, `sqrt`, `floor`, `dot`, `mul_add` (FMA)
- `Sum`, `Index`, `From`/`Into` array, `Clone`, `Copy`, `Debug`, `PartialEq`
- Transcendentals: `sin`, `cos`, `exp` — ported from [SLEEF](https://github.com/shibatch/sleef)

## Transcendental accuracy

`sin` and `cos` use SLEEF's `xsinf_u1` / `xcosf_u1` algorithms (ULP < 1 variants). `exp` uses SLEEF's `xexpf`.

| Function | Algorithm | ULP error | Range |
|----------|-----------|-----------|-------|
| `sin` | Cody-Waite + Payne-Hanek + double-float polynomial | ≤ 1.0 | all finite f32 |
| `cos` | Cody-Waite + Payne-Hanek + double-float polynomial | ≤ 1.0 | all finite f32 |
| `exp` | ln(2) range reduction + degree-6 polynomial + ldexp | ≤ 1.0 | all finite f32 |

Key implementation details:

- **Range reduction** for `sin`/`cos`: Cody-Waite (3-constant) for |x| < 125, Payne-Hanek table-based (`rempif`) for larger arguments
- **Double-float arithmetic**: FMA-based error-free transformations for high precision in the polynomial evaluation
- **Edge cases**: NaN/Inf propagation, sin(-0) = -0, exp(-inf) = 0, exp(inf) = inf
- Polynomial coefficients, constants (`PI_A2f`, `PI_B2f`, `PI_C2f`, `L2Uf`, `L2Lf`, etc.), and the 416-entry `Sleef_rempitabsp` table are taken directly from SLEEF

## Required CPU features

SSE4.1, AVX2, FMA3. Enabled globally via `.cargo/config.toml`:

```toml
[build]
rustflags = ["-C", "target-feature=+sse4.1,+avx2,+fma"]
```

## Usage

```rust
use simd_vector::{Vec4, Vec8};

let a = Vec4([1.0, 2.0, 3.0, 4.0]);
let b = Vec4([5.0, 6.0, 7.0, 8.0]);
let c = a + b;              // [6.0, 8.0, 10.0, 12.0]
let d = a.dot(b);           // 70.0
let s = a.sin();            // per-lane sin
let e = Vec8::splat(1.0).exp(); // [e, e, e, e, e, e, e, e]
```

## Tests

189 tests covering all operations, edge cases (NaN, Inf, -0.0, subnormals), and ULP sweep verification over the full range.

```
cargo test
```

Coverage (via `cargo llvm-cov`):

```
Filename   Regions  Missed  Cover   Functions  Missed  Cover   Lines  Missed  Cover
lib.rs     142      0       100.00% 6          0       100.00% 61     0       100.00%
vec4.rs    892      0       100.00% 48         0       100.00% 437    0       100.00%
vec8.rs    915      0       100.00% 48         0       100.00% 441    0       100.00%
TOTAL      1949     0       100.00% 102        0       100.00% 939    0       100.00%
```

## License

MIT