sim-engine 0.4.2

A validated high-performance visualization engine for simulations
Documentation
use super::super::certificate::Certificate;
use super::*;
use crate::renderer::{CameraUniform, LogicalViewport, screen_camera};

fn screen_uniform(width: f32, height: f32) -> CameraUniform {
    let viewport = LogicalViewport::new(width, height).unwrap();
    CameraUniform::new(screen_camera(viewport).unwrap(), viewport).unwrap()
}

#[test]
fn certificate_acceptance_implies_independent_per_corner_interval_acceptance() {
    let mut seed = 0x92ec_6754_992b_f731_u64;
    let mut next = || {
        seed ^= seed << 13;
        seed ^= seed >> 7;
        seed ^= seed << 17;
        (seed >> 32) as u32
    };
    let mut accepted = 0;
    let mut fallback = 0;
    for index in 0..24_000 {
        let magnitudes = [0.00001, 0.01, 1.0, 100.0, 1_000.0, 10_000.0, 1_000_000.0];
        let magnitude = magnitudes[index % magnitudes.len()];
        let x = (next() as f64 / f64::from(u32::MAX) * 2.0 - 1.0) as f32 * magnitude;
        let y = (next() as f64 / f64::from(u32::MAX) * 2.0 - 1.0) as f32 * magnitude;
        let width = [0.0001, 0.1, 0.5, 1.0, 2.0, 4.0, 20.0, 100.0][index % 8];
        let primitive = match index % 3 {
            0 => ScreenPrimitive2d::circle(
                LogicalScreenPosition::new(x, y),
                LogicalPixels::new(width).unwrap(),
                Color::WHITE,
            ),
            1 => ScreenPrimitive2d::round_line(
                LogicalScreenPosition::new(x, y),
                LogicalScreenPosition::new(x + 17.25, y - 6.75),
                LogicalPixels::new(width).unwrap(),
                Color::WHITE,
            ),
            _ => ScreenPrimitive2d::rect(
                LogicalScreenPosition::new(x, y),
                LogicalScreenVector::new(width, width * 3.0),
                Color::WHITE,
            ),
        };
        let Ok(primitive) = primitive else { continue };
        let certificate = Certificate::new(&[primitive.gpu]);
        let viewport = [
            (1280.0, 800.0),
            (853.3333, 533.3333),
            (3840.0, 2160.0),
            (16.0, 16.0),
            (131072.0, 131072.0),
        ][index % 5];
        let mut uniform = screen_uniform(viewport.0, viewport.1);
        if index % 11 == 0 {
            uniform.screen_to_clip[2] = 0.5;
            uniform.screen_to_clip[3] = -0.5;
        }
        if certificate.accepts(uniform) {
            accepted += 1;
            assert!(
                validation::instances_are_safe(&[primitive.gpu], uniform),
                "index={index}, primitive={primitive:?}"
            );
        } else {
            fallback += 1;
        }
    }
    assert!(accepted > 1_000, "accepted={accepted}");
    assert!(fallback > 1_000, "fallback={fallback}");
}

#[test]
fn certificate_falls_back_for_noncanonical_and_extreme_uniforms() {
    let primitive = ScreenPrimitive2d::circle(
        LogicalScreenPosition::new(-0.0, 0.0),
        LogicalPixels::new(4.0).unwrap(),
        Color::WHITE,
    )
    .unwrap();
    let certificate = Certificate::new(&[primitive.gpu]);
    let uniform = screen_uniform(1280.0, 800.0);
    assert!(certificate.accepts(uniform));
    for value in [f32::MAX, f32::MIN_POSITIVE, -0.0, f32::NAN, f32::INFINITY] {
        let mut changed = uniform;
        changed.screen_to_clip[0] = value;
        assert!(!certificate.accepts(changed));
    }
    let mut changed = uniform;
    changed.world_to_screen_x[0] = 1.00001;
    assert!(!certificate.accepts(changed));
}

#[test]
fn every_uniform_field_participates_in_certificate_or_independent_fallback() {
    let primitive = ScreenPrimitive2d::circle(
        LogicalScreenPosition::new(75.25, 48.5),
        LogicalPixels::new(4.0).unwrap(),
        Color::WHITE,
    )
    .unwrap();
    let certificate = Certificate::new(&[primitive.gpu]);
    let original = screen_uniform(1280.0, 800.0);
    for field in 0..16 {
        for value in [
            0.0,
            -0.0,
            1.0,
            -1.0,
            f32::from_bits(1),
            f32::MIN_POSITIVE,
            f32::MAX,
            -f32::MAX,
            f32::INFINITY,
            f32::NAN,
        ] {
            let mut changed = original;
            let values: &mut [f32] = bytemuck::cast_slice_mut(std::slice::from_mut(&mut changed));
            values[field] = value;
            if certificate.accepts(changed) {
                assert!(
                    validation::instances_are_safe(&[primitive.gpu], changed),
                    "field={field} value={value}"
                );
            }
            assert_eq!(
                validation::instances_are_safe_accelerated(&[primitive.gpu], certificate, changed),
                validation::instances_are_safe(&[primitive.gpu], changed),
                "field={field} value={value}",
            );
        }
    }
}

#[test]
fn newly_certified_two_to_eight_error_edge_separations_match_exact_interval_proof() {
    let mut newly_admitted = 0;
    for size in [128.0, 256.0, 640.0, 1280.0, 2560.0, 8192.0] {
        let uniform = screen_uniform(size, size * 0.75);
        for fraction in [-0.125, 0.125, 0.75] {
            for width in [0.5, 1.25, 2.0, 8.0] {
                for slope in 1..=32 {
                    let x = size * fraction + 0.375;
                    let y = size * fraction + 0.625;
                    let primitive = ScreenPrimitive2d::round_line(
                        LogicalScreenPosition::new(x, y),
                        LogicalScreenPosition::new(x + 10.0, y + slope as f32 * 0.0625),
                        LogicalPixels::new(width).unwrap(),
                        Color::WHITE,
                    )
                    .unwrap();
                    let certificate = Certificate::new(&[primitive.gpu]);
                    let ratio = certificate.edge_separation_ratio(uniform);
                    if ratio > 2.0 && ratio <= 8.0 && certificate.accepts(uniform) {
                        newly_admitted += 1;
                        assert!(
                            validation::instances_are_safe(&[primitive.gpu], uniform),
                            "size={size} fraction={fraction} width={width} slope={slope} separation={ratio}"
                        );
                    }
                }
            }
        }
    }
    assert!(newly_admitted > 300, "newly admitted={newly_admitted}");
}

#[test]
fn math_ellipse_fixture_certificate_hits_all_terminal_directions() {
    let uniform = screen_uniform(1280.0, 800.0);
    let mut accepted = 0;
    let mut fallback = 0;
    for center in [[100.375_f32, 100.625_f32], [1190.375, 730.625]] {
        for zoom in [0.92, 1.0, 1.08] {
            for segment in 0..13 {
                let angle = segment as f32 * std::f32::consts::TAU / 13.0;
                let next = (segment + 1) as f32 * std::f32::consts::TAU / 13.0;
                let primitive = ScreenPrimitive2d::round_line(
                    LogicalScreenPosition::new(
                        center[0] + angle.cos() * 17.0 * zoom,
                        center[1] + angle.sin() * 13.0 * zoom,
                    ),
                    LogicalScreenPosition::new(
                        center[0] + next.cos() * 17.0 * zoom,
                        center[1] + next.sin() * 13.0 * zoom,
                    ),
                    LogicalPixels::new(1.25).unwrap(),
                    Color::WHITE,
                )
                .unwrap();
                let certificate = Certificate::new(&[primitive.gpu]);
                if certificate.accepts(uniform) {
                    accepted += 1;
                } else {
                    fallback += 1;
                }
                assert!(validation::instances_are_safe_accelerated(
                    &[primitive.gpu],
                    certificate,
                    uniform
                ));
                assert!(validation::instances_are_safe(&[primitive.gpu], uniform));
            }
        }
    }
    assert_eq!((accepted, fallback), (78, 0));
    eprintln!("math ellipse certificate accepted={accepted}, fallback={fallback}");
}

#[test]
fn source_and_destination_precision_reject_visible_large_shape_distortion() {
    assert!(matches!(
        ScreenPrimitive2d::rect(
            LogicalScreenPosition::new(100.0, 100.0),
            LogicalScreenVector::new(1e10, 600.0),
            Color::WHITE
        ),
        Err(ScreenPrimitiveError::PrecisionLimit)
    ));
    assert!(matches!(
        ScreenPrimitive2d::round_line(
            LogicalScreenPosition::new(-1e10, 400.0),
            LogicalScreenPosition::new(100.0, 400.0),
            LogicalPixels::new(600.0).unwrap(),
            Color::WHITE
        ),
        Err(ScreenPrimitiveError::PrecisionLimit | ScreenPrimitiveError::InvalidGeometry)
    ));
    assert!(matches!(
        ScreenPrimitive2d::circle(
            LogicalScreenPosition::new(-1e8, -1e8),
            LogicalPixels::new(141_421_776.0).unwrap(),
            Color::WHITE
        ),
        Err(ScreenPrimitiveError::PrecisionLimit)
    ));
    let primitive = ScreenPrimitive2d::circle(
        LogicalScreenPosition::new(300.25, 250.5),
        LogicalPixels::new(2.5).unwrap(),
        Color::WHITE,
    )
    .unwrap();
    let quality = quality::Quality::new(&[primitive]);
    let uniform = screen_uniform(1280.0, 800.0);
    for scale in [1.0, 1.25, 1.5, 2.0, 4.0] {
        assert!(quality.accepts(uniform, scale));
    }
    for scale in [0.0, -0.0, -1.0, f32::NAN, f32::INFINITY, 100.0] {
        assert!(!quality.accepts(uniform, scale));
    }
}

#[test]
fn short_capsules_keep_nonintegral_ratios_inside_the_precision_envelope() {
    for index in 1..=2000 {
        let length = 0.0001 + (index as f32 / 2000.0);
        let width = 1.0 + (index % 20) as f32;
        ScreenPrimitive2d::round_line(
            LogicalScreenPosition::new(10.0, 10.0),
            LogicalScreenPosition::new(10.0 + length, 10.0),
            LogicalPixels::new(width).unwrap(),
            Color::WHITE,
        )
        .unwrap();
    }
}