Function test_sinusoidal_pe

tests/test_phase3.cpp:183–242

// ═══════════════════════════════════════════════════════════════════════════════

static void test_sinusoidal_pe(const std::string & ref_dir, int & n_pass, int & n_fail) {
    fprintf(stderr, "\n╔══════════════════════════════════════════╗\n");
    fprintf(stderr, "║  Test: Sinusoidal PE                     ║\n");
    fprintf(stderr, "╚══════════════════════════════════════════╝\n");

    struct { int H; int W; const char * name; } cases[] = {
        {288, 288, "pe_288"},
        {144, 144, "pe_144"},
        { 72,  72, "pe_72"},
        { 36,  36, "pe_36"},
    };

    for (auto & tc : cases) {
        auto ref = load_ref(ref_dir + "/" + tc.name);
        if (ref.data.empty()) continue;

        const int H = tc.H, W = tc.W, d_model = 256;
        const int half = d_model / 2;  // 128
        const float scale = 2.0f * (float)M_PI;
        const float temperature = 10000.0f;

        // Match Python PositionEmbeddingSine.forward() exactly:
        // y_embed = arange(1, H+1) / (H + eps) * scale
        // dim_t = temperature ** (2 * (arange(half) // 2) / half)
        // pos_y = y_embed / dim_t
        // stack(sin(even), cos(odd)).flatten → interleaved sin/cos
        // Output: [1, 256, H, W] (NCHW)

        std::vector<float> our_pe(d_model * H * W);
        const float eps = 1e-6f;

        for (int y = 0; y < H; ++y) {
            for (int x = 0; x < W; ++x) {
                float pos_y = ((float)(y + 1) / ((float)H + eps)) * scale;
                float pos_x = ((float)(x + 1) / ((float)W + eps)) * scale;

                for (int i = 0; i < half; ++i) {
                    int paired = (i / 2) * 2;  // 0,0,2,2,4,4,...
                    float dim_t = powf(temperature, (float)paired / (float)half);

                    float val_x, val_y;
                    if (i % 2 == 0) {
                        val_x = sinf(pos_x / dim_t);
                        val_y = sinf(pos_y / dim_t);
                    } else {
                        val_x = cosf(pos_x / dim_t);
                        val_y = cosf(pos_y / dim_t);
                    }

                    // PyTorch output is [1, 256, H, W]
                    // Channel layout: first 128 = pos_y, next 128 = pos_x
                    our_pe[i * H * W + y * W + x] = val_y;
                    our_pe[(i + half) * H * W + y * W + x] = val_x;
                }
            }
        }

        check(tc.name, our_pe.data(), ref, 1e-5f, n_pass, n_fail);