Initial Dever 0.0.1

test/rust/performance/numeric/mod.rs

@@ -0,0 +1,104 @@
+fn decimal_generated(values: &[Option<Decimal>]) -> Result<i64, Fault> {
+    let mut total = 0i64;
+    for value in values {
+        total += GENERATED_DECIMAL(value)?;
+    }
+    Ok(total)
+}
+
+fn decimal_reference(values: &[Option<Decimal>]) -> Result<i64, Fault> {
+    let mut total = 0i64;
+    let zero = Decimal::from_int(0);
+    for value in values {
+        total += match value {
+            None => 2,
+            Some(value) if *value < zero => -1,
+            Some(value) if *value == zero => 0,
+            Some(_) => 1,
+        };
+    }
+    Ok(total)
+}
+
+fn edge_generated(values: &[Decimal]) -> Result<i64, Fault> {
+    let mut total = 0i64;
+    for value in values {
+        total += GENERATED_EDGE(*value)?;
+    }
+    Ok(total)
+}
+
+fn edge_reference(values: &[Decimal]) -> Result<i64, Fault> {
+    let mut total = 0i64;
+    let one = Decimal::from_int(1);
+    for value in values {
+        total += i64::from(*value > one);
+    }
+    Ok(total)
+}
+
+fn float_generated(values: &[Option<f64>]) -> Result<i64, Fault> {
+    let mut total = 0i64;
+    for value in values {
+        total += GENERATED_FLOAT(value)?;
+    }
+    Ok(total)
+}
+
+fn float_reference(values: &[Option<f64>]) -> Result<i64, Fault> {
+    let mut total = 0i64;
+    for value in values {
+        total += match value {
+            None => -1,
+            Some(value) if *value == 1.0 => 1,
+            Some(value) if *value == 0.0 => 0,
+            Some(_) => 2,
+        };
+    }
+    Ok(total)
+}
+
+fn main() {
+    let decimals = (0..256).map(|index| match index % 4 {
+        0 => None,
+        1 => Some(Decimal::from_int(-(index as i64))),
+        2 => Some(Decimal::from_int(0)),
+        _ => Some(Decimal::from_int(index as i64)),
+    }).collect::<Vec<_>>();
+    let edges = ["0", "1", "1.000000000000000000000000000000001", "2"];
+    let edges = (0..256).map(|index| Decimal::parse(edges[index % 4]).unwrap()).collect::<Vec<_>>();
+    let special = [None, Some(0.0), Some(-0.0), Some(1.0), Some(-1.0), Some(f64::NAN), Some(f64::INFINITY), Some(f64::NEG_INFINITY)];
+    let floats = (0..256).map(|index| special[index % special.len()]).collect::<Vec<_>>();
+    for value in &decimals { assert_eq!(GENERATED_DECIMAL(value).unwrap(), decimal_reference(&[*value]).unwrap()); }
+    for value in &edges { assert_eq!(GENERATED_EDGE(*value).unwrap(), edge_reference(&[*value]).unwrap()); }
+    for value in &floats { assert_eq!(GENERATED_FLOAT(value).unwrap(), float_reference(&[*value]).unwrap()); }
+    println!("case,sample,implementation,elapsed_ns,checksum");
+    compare("decimal_clauses", &decimals, 10000, decimal_generated, decimal_reference, |value| *value as u64);
+    compare("decimal_adjacent", &edges, 10000, edge_generated, edge_reference, |value| *value as u64);
+    compare("float_clauses", &floats, 10000, float_generated, float_reference, |value| *value as u64);
+
+    // 独立保留原三组；混合输入覆盖非整数、不同小数位、负零和指数极限。
+    let spellings = [
+        "-9.999999999999999999999999999999999E+6144",
+        "-1234567890123456789012345678901234",
+        "-1.000000000000000000000000000000001",
+        "-1.00", "-0.001", "-1E-6176", "-0.00", "0", "0E+100",
+        "1E-6176", "0.001", "0.9999999999999999999999999999999999",
+        "1", "1.000", "1.000000000000000000000000000000001",
+        "1234567890123456789012345678901234",
+        "9.999999999999999999999999999999999E+6144",
+    ];
+    let palette = spellings.map(|text| Decimal::parse(text).unwrap());
+    let mut state = 0x123456789abcdef0u64;
+    let mixed = (0..256).map(|_| {
+        state = state.wrapping_mul(6364136223846793005).wrapping_add(1);
+        palette[((state >> 32) as usize) % palette.len()]
+    }).collect::<Vec<_>>();
+    let nullable = mixed.iter().enumerate().map(|(index, value)| {
+        if index % 5 == 0 { None } else { Some(*value) }
+    }).collect::<Vec<_>>();
+    for value in &nullable { assert_eq!(GENERATED_DECIMAL(value).unwrap(), decimal_reference(&[*value]).unwrap()); }
+    for value in &mixed { assert_eq!(GENERATED_EDGE(*value).unwrap(), edge_reference(&[*value]).unwrap()); }
+    compare("decimal_mixed_clauses", &nullable, 10000, decimal_generated, decimal_reference, |value| *value as u64);
+    compare("decimal_mixed_adjacent", &mixed, 10000, edge_generated, edge_reference, |value| *value as u64);
+}