tenflowers-core 0.1.1

Core tensor operations and execution engine for TenfloweRS
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

//! Data compression formats for WASM-optimized tensors

/// Compressed data storage for WASM deployment
#[cfg(feature = "wasm")]
#[derive(Debug)]
pub enum WasmCompressedData<T> {
    /// Dense storage for small tensors
    Dense(Vec<T>),
    /// Sparse storage for large sparse tensors
    Sparse(WasmSparseData<T>),
    /// Quantized storage for reduced precision
    Quantized(WasmQuantizedData),
    /// Run-length encoded for repetitive data
    RunLength(WasmRunLengthData<T>),
}

/// Sparse data representation optimized for WASM
#[cfg(feature = "wasm")]
#[derive(Debug)]
pub struct WasmSparseData<T> {
    /// Non-zero values
    pub values: Vec<T>,
    /// Row indices (CSR format)
    pub row_ptr: Vec<u32>,
    /// Column indices
    pub col_indices: Vec<u32>,
    /// Number of non-zero elements
    pub nnz: usize,
}

/// Quantized data for reduced memory usage
#[cfg(feature = "wasm")]
#[derive(Debug)]
pub struct WasmQuantizedData {
    /// Quantized values (8-bit or 16-bit)
    pub quantized_values: Vec<u8>,
    /// Scale factor for dequantization
    pub scale: f32,
    /// Zero point for quantization
    pub zero_point: i32,
    /// Quantization bit width
    pub bit_width: u8,
}

/// Run-length encoded data for repetitive patterns
#[cfg(feature = "wasm")]
#[derive(Debug)]
pub struct WasmRunLengthData<T> {
    /// Unique values
    pub values: Vec<T>,
    /// Run lengths
    pub lengths: Vec<u32>,
}

/// Compression configuration
#[cfg(feature = "wasm")]
#[derive(Debug, Clone)]
pub struct CompressionConfig {
    /// Enable Brotli compression
    pub brotli: bool,
    /// Enable Gzip compression
    pub gzip: bool,
    /// Compression level (1-9)
    pub compression_level: u8,
    /// Enable model weight compression
    pub compress_weights: bool,
}

#[cfg(feature = "wasm")]
impl Default for CompressionConfig {
    fn default() -> Self {
        Self {
            brotli: true,
            gzip: true,
            compression_level: 9,
            compress_weights: true,
        }
    }
}

#[cfg(feature = "wasm")]
impl CompressionConfig {
    /// Create new compression configuration
    pub fn new() -> Self {
        Self::default()
    }

    /// Create minimal compression configuration for size optimization
    pub fn minimal() -> Self {
        Self {
            brotli: true,
            gzip: false,
            compression_level: 9,
            compress_weights: true,
        }
    }

    /// Create fast compression configuration for speed optimization
    pub fn fast() -> Self {
        Self {
            brotli: false,
            gzip: true,
            compression_level: 1,
            compress_weights: false,
        }
    }
}

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

    #[test]
    #[cfg(feature = "wasm")]
    fn test_compression_config() {
        let config = CompressionConfig::new();
        assert!(config.brotli);
        assert_eq!(config.compression_level, 9);

        let minimal = CompressionConfig::minimal();
        assert!(minimal.brotli);
        assert!(!minimal.gzip);

        let fast = CompressionConfig::fast();
        assert!(!fast.brotli);
        assert!(fast.gzip);
        assert_eq!(fast.compression_level, 1);
    }
}