vyre-libs 0.7.2

vyre Category A library ecosystem - pure-IR compositions over foundation IR and primitive-owned kernels
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

mod glass {
    use vyre_libs::visual::glass::{
        glass_blur_stage, glass_filter_stage, glass_stages, GlassParams,
    };

    fn default_params() -> GlassParams {
        GlassParams {
            width: 16,
            height: 16,
            blur_radius: 4,
            blur_sigma: 1.5,
            tint_rgba: 0x0D_FFFFFF,
            brightness: 1.0,
            saturation: 0.75,
        }
    }

    #[test]
    fn blur_stage_builds() {
        let params = default_params();
        let stages = glass_blur_stage("scene", "out", "tmp", &params);
        assert_eq!(stages.stage_count(), 2);
    }

    #[test]
    fn filter_stage_builds() {
        let params = default_params();
        let prog = glass_filter_stage("blurred", &params);
        assert_eq!(prog.buffers().len(), 1);
    }

    #[test]
    fn stages_returns_two_programs() {
        let params = default_params();
        let (blur, tint) = glass_stages("scene", "out", "tmp", &params);
        assert_eq!(blur.stage_count(), 2, "blur needs two dispatches");
        assert_eq!(tint.buffers().len(), 1, "tint stage works in-place");
    }

    #[test]
    fn builds_with_zero_blur() {
        let params = GlassParams {
            blur_radius: 0,
            blur_sigma: 0.1,
            ..default_params()
        };
        let (blur, _tint) = glass_stages("s", "o", "t", &params);
        assert_eq!(blur.stage_count(), 2);
    }

    #[test]
    fn builds_with_1x1_image() {
        let params = GlassParams {
            width: 1,
            height: 1,
            ..default_params()
        };
        let (blur, tint) = glass_stages("s", "o", "t", &params);
        assert_eq!(blur.stage_count(), 2);
        assert_eq!(tint.buffers().len(), 1);
    }
}

// ================================================================
// conv1d Tier 2.5 primitive tests
// ================================================================

mod conv1d {
    use vyre_primitives::math::conv1d::{
        conv1d_program, gaussian_weights, pack_params, MAX_RADIUS,
    };

    #[test]
    fn program_has_four_buffers() {
        let prog = conv1d_program(16, 2);
        assert_eq!(
            prog.buffers().len(),
            4,
            "conv1d: input + output + weights + params"
        );
        assert_eq!(
            prog.workgroup_size(),
            [256, 1, 1],
            "conv1d must declare local workgroup size, not precomputed dispatch groups"
        );
    }

    #[test]
    fn pack_params_clamps_radius() {
        let params = pack_params(100, 1, 200); // radius 200 > MAX_RADIUS
        assert_eq!(params[2], MAX_RADIUS, "radius should be clamped");
    }

    #[test]
    fn gaussian_weights_singleton() {
        let w = gaussian_weights(0, 1.0);
        assert_eq!(w, vec![65536], "radius=0 → single weight at 1.0");
    }

    #[test]
    fn gaussian_weights_center_is_maximum() {
        let w = gaussian_weights(4, 1.5);
        let center = w.len() / 2;
        for (i, &val) in w.iter().enumerate() {
            if i != center {
                assert!(val <= w[center], "center weight must be the maximum");
            }
        }
    }

    #[test]
    fn program_radius_clamp_to_max() {
        let prog = conv1d_program(32, MAX_RADIUS + 100);
        let bufs = prog.buffers();
        // Weights buffer should have diameter = 2*MAX_RADIUS+1 = 129 elements.
        let weights_buf = &bufs[2];
        assert_eq!(weights_buf.name(), "weights");
    }
}