Function TEST_F

tests/test_tensor_compat.cpp:104–134

// ============= Complex Expression Tests =============

TEST_F(TensorTorchCompatTest, ComplexExpression1) {
    // Test: (a + b) * c - d / e
    std::vector<float> data_a(12), data_b(12), data_c(12), data_d(12), data_e(12);
    for (auto& val : data_a)
        val = dist(gen);
    for (auto& val : data_b)
        val = dist(gen);
    for (auto& val : data_c)
        val = dist(gen);
    for (auto& val : data_d)
        val = dist(gen);
    for (auto& val : data_e)
        val = std::abs(dist(gen)) + 1.0f; // Avoid division by zero

    auto custom_a = Tensor::from_vector(data_a, {3, 4}, Device::CUDA);
    auto custom_b = Tensor::from_vector(data_b, {3, 4}, Device::CUDA);
    auto custom_c = Tensor::from_vector(data_c, {3, 4}, Device::CUDA);
    auto custom_d = Tensor::from_vector(data_d, {3, 4}, Device::CUDA);
    auto custom_e = Tensor::from_vector(data_e, {3, 4}, Device::CUDA);

    auto torch_a = torch::tensor(data_a, torch::TensorOptions().device(torch::kCUDA)).reshape({3, 4});
    auto torch_b = torch::tensor(data_b, torch::TensorOptions().device(torch::kCUDA)).reshape({3, 4});
    auto torch_c = torch::tensor(data_c, torch::TensorOptions().device(torch::kCUDA)).reshape({3, 4});
    auto torch_d = torch::tensor(data_d, torch::TensorOptions().device(torch::kCUDA)).reshape({3, 4});
    auto torch_e = torch::tensor(data_e, torch::TensorOptions().device(torch::kCUDA)).reshape({3, 4});

    auto custom_result = (custom_a + custom_b) * custom_c - custom_d / custom_e;
    auto torch_result = (torch_a + torch_b) * torch_c - torch_d / torch_e;

    compare_tensors(custom_result, torch_result, 1e-4f, 1e-5f, "ComplexExpression1");
}

TEST_F(TensorTorchCompatTest, ComplexExpression2) {
    // Test: sigmoid(a * 2 + b) * relu(c - 1)