vyre-libs 0.6.3

vyre Category A library ecosystem - pure-IR compositions over vyre-ops hardware primitives
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");
        }
    }