pub fn compress_numeric<T: Copy>(data: &[T]) -> Result<Vec<u8>, Error>Expand description
Compress numeric data using the NUMERIC graph (optimized for numeric arrays).
Supports all numeric types: u8, u16, u32, u64, i8, i16, i32, i64, f32, f64.
§Example
let data: Vec<u32> = (0..10000).collect();
let compressed = compress_numeric(&data).expect("compression failed");Examples found in repository?
examples/numeric_compress.rs (line 16)
8fn main() -> Result<(), Box<dyn std::error::Error>> {
9 println!("=== Numeric Compression Examples ===\n");
10
11 // Example 1: Sequential u32 data (highly compressible)
12 println!("Example 1: Sequential u32 data");
13 let sequential: Vec<u32> = (0..10000).collect();
14 let original_size = sequential.len() * std::mem::size_of::<u32>();
15
16 let compressed = compress_numeric(&sequential)?;
17
18 println!(" Original size: {} bytes ({} elements)", original_size, sequential.len());
19 println!(" Compressed size: {} bytes", compressed.len());
20 println!(
21 " Compression ratio: {:.2}%",
22 (compressed.len() as f64 / original_size as f64) * 100.0
23 );
24
25 let decompressed: Vec<u32> = decompress_numeric(&compressed)?;
26 assert_eq!(sequential, decompressed);
27 println!(" ✓ Round-trip successful!\n");
28
29 // Example 2: u64 data with large values
30 println!("Example 2: u64 data with timestamps");
31 let timestamps: Vec<u64> = (0..1000).map(|i| 1700000000000 + i * 1000).collect();
32 let original_size = timestamps.len() * std::mem::size_of::<u64>();
33
34 let compressed = compress_numeric(×tamps)?;
35
36 println!(" Original size: {} bytes ({} elements)", original_size, timestamps.len());
37 println!(" Compressed size: {} bytes", compressed.len());
38 println!(
39 " Compression ratio: {:.2}%",
40 (compressed.len() as f64 / original_size as f64) * 100.0
41 );
42
43 let decompressed: Vec<u64> = decompress_numeric(&compressed)?;
44 assert_eq!(timestamps, decompressed);
45 println!(" ✓ Round-trip successful!\n");
46
47 // Example 3: i32 data with mixed positive/negative values
48 println!("Example 3: i32 sensor readings");
49 let sensor_data: Vec<i32> = (0..5000)
50 .map(|i| ((i as f64 * 0.1).sin() * 100.0) as i32)
51 .collect();
52 let original_size = sensor_data.len() * std::mem::size_of::<i32>();
53
54 let compressed = compress_numeric(&sensor_data)?;
55
56 println!(" Original size: {} bytes ({} elements)", original_size, sensor_data.len());
57 println!(" Compressed size: {} bytes", compressed.len());
58 println!(
59 " Compression ratio: {:.2}%",
60 (compressed.len() as f64 / original_size as f64) * 100.0
61 );
62
63 let decompressed: Vec<i32> = decompress_numeric(&compressed)?;
64 assert_eq!(sensor_data, decompressed);
65 println!(" ✓ Round-trip successful!\n");
66
67 // Example 4: f64 floating-point data
68 println!("Example 4: f64 scientific measurements");
69 let measurements: Vec<f64> = (0..1000)
70 .map(|i| i as f64 * 2.718281828 + 0.001)
71 .collect();
72 let original_size = measurements.len() * std::mem::size_of::<f64>();
73
74 let compressed = compress_numeric(&measurements)?;
75
76 println!(" Original size: {} bytes ({} elements)", original_size, measurements.len());
77 println!(" Compressed size: {} bytes", compressed.len());
78 println!(
79 " Compression ratio: {:.2}%",
80 (compressed.len() as f64 / original_size as f64) * 100.0
81 );
82
83 let decompressed: Vec<f64> = decompress_numeric(&compressed)?;
84 assert_eq!(measurements, decompressed);
85 println!(" ✓ Round-trip successful!\n");
86
87 println!("All numeric compression examples completed successfully!");
88
89 Ok(())
90}