Initial Dever 0.0.1

test/rust/performance/numeric/range.rs

@@ -0,0 +1,69 @@
+fn reference_ports(values: &[PORT_TYPE]) -> Result<i64, Fault> {
+    let fault = &FaultInfo { message: "integer arithmetic fault", source: "Rust reference", line: 0, column: 0 };
+    let mut total = 0i64;
+    for value in values {
+        let value = value.field0.checked_add(1).ok_or(fault)?;
+        total = total.checked_add(value).ok_or(fault)?;
+    }
+    Ok(total)
+}
+
+// 两处溢出保留各自来源；原单一错误参照仍用于观察诊断语义的成本。
+fn reference_ports_distinct_faults(values: &[PORT_TYPE]) -> Result<i64, Fault> {
+    let mut total = 0i64;
+    for value in values {
+        let adjusted = value.field0.checked_add(1).ok_or(&FaultInfo {
+            message: "integer arithmetic fault", source: "Rust reference", line: 1, column: 1,
+        })?;
+        total = total.checked_add(adjusted).ok_or(&FaultInfo {
+            message: "integer overflow", source: "Rust reference", line: 2, column: 1,
+        })?;
+    }
+    Ok(total)
+}
+
+// Port 只允许 1..=65535，加一不可能溢出；累计仍按 Int 合同检查。
+fn reference_ports_bounded(values: &[PORT_TYPE]) -> Result<i64, Fault> {
+    let mut total = 0i64;
+    for value in values {
+        total = total.checked_add(value.field0.wrapping_add(1)).ok_or(&FaultInfo {
+            message: "integer overflow", source: "Rust reference", line: 2, column: 1,
+        })?;
+    }
+    Ok(total)
+}
+
+const SCALE: [u8; 16] = [34, 7, 192, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0];
+
+fn reference_rates(values: &[RATE_TYPE]) -> Result<Decimal, Fault> {
+    let fault = &FaultInfo { message: "decimal arithmetic fault", source: "Rust reference", line: 0, column: 0 };
+    let scale = dec::Decimal128::from_be_bytes(SCALE);
+    let mut context = dec::Context::<dec::Decimal128>::default();
+    let mut total = dec::Decimal128::ZERO;
+    for value in values {
+        context.clear_status();
+        let value = context.mul(dec::Decimal128::from_be_bytes(value.field0.to_be_bytes()), scale);
+        if !value.is_finite() || context.status().overflow() || context.status().invalid_operation() { return Err(fault); }
+        context.clear_status();
+        total = context.add(total, value);
+        if !total.is_finite() || context.status().overflow() || context.status().invalid_operation() { return Err(fault); }
+    }
+    Ok(Decimal::from_be_bytes(total.to_be_bytes()))
+}
+
+fn main() {
+    assert_eq!(Decimal::parse("100.0").unwrap().to_be_bytes(), SCALE);
+    for values in [vec![], vec![1], vec![65535], vec![1, 65535], vec![32768, 32767]] {
+        let ports = values.into_iter().map(|field0| PORT_TYPE { field0 }).collect::<Vec<_>>();
+        assert_eq!(GENERATED_TOTAL(&ports).map_err(|fault| fault.message), reference_ports_distinct_faults(&ports).map_err(|fault| fault.message));
+        assert_eq!(GENERATED_TOTAL(&ports).map_err(|fault| fault.message), reference_ports_bounded(&ports).map_err(|fault| fault.message));
+    }
+    println!("case,sample,implementation,elapsed_ns,checksum");
+    let ports = (0..64).map(|index| PORT_TYPE { field0: index * 1000 + 1 }).collect::<Vec<_>>();
+    compare("range_int", &ports, 100_000, GENERATED_TOTAL, reference_ports, |value| *value as u64);
+    compare("range_int_distinct_faults", &ports, 100_000, GENERATED_TOTAL, reference_ports_distinct_faults, |value| *value as u64);
+    compare("range_int_bounded", &ports, 100_000, GENERATED_TOTAL, reference_ports_bounded, |value| *value as u64);
+    let rates = (0..32).map(|index| RATE_TYPE { field0: Decimal::parse(&format!("0.{index:02}")).unwrap() }).collect::<Vec<_>>();
+    assert_eq!(GENERATED_RATES(&rates).unwrap().to_be_bytes(), reference_rates(&rates).unwrap().to_be_bytes());
+    compare("range_decimal", &rates, 5_000, GENERATED_RATES, reference_rates, |value| u64::from(value.to_be_bytes()[15]));
+}