aprender-compute 0.32.0

High-performance SIMD compute library with GPU support, LLM inference engine, and GGUF model loading (was: trueno)
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

// ============================================================================
// F4: Quantization Parity Oracle -- SIMD/GPU Numerical Accuracy
// ============================================================================

use trueno_cuda_edge::quant_oracle::{
    check_values_parity, BoundaryValueGenerator, ParityConfig, QuantFormat,
};

/// Test format-specific tolerances for trueno's quantization.
#[test]
fn quantization_format_tolerances() {
    // 4-bit quantization: ~5% tolerance
    assert!((QuantFormat::Q4K.tolerance() - 0.05).abs() < f64::EPSILON);

    // 5-bit quantization: ~2% tolerance
    assert!((QuantFormat::Q5K.tolerance() - 0.02).abs() < f64::EPSILON);

    // 6-bit quantization: ~1% tolerance
    assert!((QuantFormat::Q6K.tolerance() - 0.01).abs() < f64::EPSILON);

    // 8-bit quantization: ~0.5% tolerance
    assert!((QuantFormat::Q8_0.tolerance() - 0.005).abs() < f64::EPSILON);

    // F16: ~0.1% tolerance
    assert!((QuantFormat::F16.tolerance() - 0.001).abs() < f64::EPSILON);

    // F32: machine epsilon
    assert!((QuantFormat::F32.tolerance() - f64::EPSILON).abs() < f64::EPSILON);
}

/// Test boundary value generation for edge cases.
#[test]
fn boundary_value_generation() {
    let gen = BoundaryValueGenerator::new(QuantFormat::Q4K);

    // Universal boundaries
    let universal = gen.universal_boundaries();
    assert!(universal.contains(&0.0));
    assert!(universal.iter().any(|v| v.is_nan()));
    assert!(universal.iter().any(|v| v.is_infinite()));

    // Format-specific boundaries
    let format_bounds = gen.format_boundaries();
    // Q4K has 16 levels x 2 (+/-) = 32 values
    assert_eq!(format_bounds.len(), 32);

    // All boundaries
    let all = gen.all_boundaries();
    assert_eq!(all.len(), universal.len() + format_bounds.len());
}

/// Test parity checking for CPU/GPU comparison.
#[test]
fn parity_check_cpu_gpu() {
    let config = ParityConfig::new(QuantFormat::Q4K);

    // Identical values: pass
    let cpu = vec![1.0, 2.0, 3.0];
    let gpu = vec![1.0, 2.0, 3.0];
    let report = check_values_parity(&cpu, &gpu, &config);
    assert!(report.passed());

    // Small difference within tolerance: pass
    let gpu_close = vec![1.01, 2.01, 3.01];
    let report = check_values_parity(&cpu, &gpu_close, &config);
    assert!(report.passed());

    // Large difference: fail
    let gpu_far = vec![1.0, 2.5, 3.0];
    let report = check_values_parity(&cpu, &gpu_far, &config);
    assert!(!report.passed());
    assert_eq!(report.violations.len(), 1);
}

/// Test NaN handling in parity checks.
#[test]
fn parity_nan_handling() {
    let config = ParityConfig::new(QuantFormat::F32);

    // NaN vs NaN: OK (both are NaN)
    let cpu = vec![f64::NAN];
    let gpu = vec![f64::NAN];
    let report = check_values_parity(&cpu, &gpu, &config);
    assert!(report.passed());

    // NaN vs number: violation
    let gpu_num = vec![1.0];
    let report = check_values_parity(&cpu, &gpu_num, &config);
    assert!(!report.passed());
}