fixed coding style with clang-format-9 and added the suggested changes

Author: vijaykr338

src/frontends/pytorch/src/op/polar.cpp

@@ -1,9 +1,8 @@
-#include "openvino/op/cos.hpp"
-#include "openvino/op/sin.hpp"
-#include "openvino/op/multiply.hpp"
-#include "openvino/op/concat.hpp"
 #include "openvino/frontend/complex_type_mark.hpp"
 #include "openvino/op/convert.hpp"
+#include "openvino/op/cos.hpp"
+#include "openvino/op/multiply.hpp"
+#include "openvino/op/sin.hpp"
 #include "utils.hpp"
 
 namespace ov {
@@ -17,15 +16,15 @@ OutputVector translate_polar(const NodeContext& context) {
     num_inputs_check(context, 2, 3);
     auto abs = context.get_input(0);
     auto angle = context.get_input(1);
-    auto real = context.mark_node(std::make_shared<v1::Multiply>(abs,context.mark_node(std::make_shared<v0::Cos>(angle))));
-    auto imag = context.mark_node(std::make_shared<v1::Multiply>(abs,context.mark_node(std::make_shared<v0::Sin>(angle))));
-    auto complex_concat = context.mark_node(std::make_shared<v0::Concat>(OutputVector{real, imag}, -1));
-    // wrap the tensor with ComplexTypeMark to flag it as complex for later operations.
-    auto complex_tensor = context.mark_node(std::make_shared<ComplexTypeMark>(complex_concat));
+    auto real =
+        context.mark_node(std::make_shared<v1::Multiply>(abs, context.mark_node(std::make_shared<v0::Cos>(angle))));
+    auto imag =
+        context.mark_node(std::make_shared<v1::Multiply>(abs, context.mark_node(std::make_shared<v0::Sin>(angle))));
+    auto complex_tensor = context.mark_node(std::make_shared<ComplexTypeMark>(real, imag));
     return {complex_tensor};
 }
 
 }  // namespace op
 }  // namespace pytorch
 }  // namespace frontend
-}  // namespace ov
+}  // namespace ov

src/frontends/pytorch/src/op/randperm.cpp

@@ -1,9 +1,9 @@
-#include "openvino/op/topk.hpp"
-#include "openvino/op/random_uniform.hpp"
 #include "openvino/frontend/pytorch/node_context.hpp"
 #include "openvino/op/constant.hpp"
-#include "utils.hpp"
+#include "openvino/op/random_uniform.hpp"
 #include "openvino/op/shape_of.hpp"
+#include "openvino/op/topk.hpp"
+#include "utils.hpp"
 
 namespace ov {
 namespace frontend {
@@ -20,25 +20,37 @@ OutputVector translate_randperm(const NodeContext& context) {
     } else if (num_inputs == 2) {
         if (!context.input_is_none(1)) {
             dtype_value = context.const_input<int>(1);
-            OPENVINO_ASSERT(dtype_value == 4, "Only dtype value 4 (int64) is supported for aten::randperm, got: ", dtype_value);
+            OPENVINO_ASSERT(dtype_value == 4,
+                            "Only dtype value 4 (int64) is supported for aten::randperm, got: ",
+                            dtype_value);
         }
     } else if (num_inputs == 5) {
         if (!context.input_is_none(1)) {
             dtype_value = context.const_input<int>(1);
-            OPENVINO_ASSERT(dtype_value == 4, "Only dtype value 4 (int64) is supported for aten::randperm, got: ", dtype_value);
+            OPENVINO_ASSERT(dtype_value == 4,
+                            "Only dtype value 4 (int64) is supported for aten::randperm, got: ",
+                            dtype_value);
         }
     } else {
-            PYTORCH_OP_CONVERSION_CHECK(false, "Unexpected number of inputs for aten::randperm: ", num_inputs);
+        PYTORCH_OP_CONVERSION_CHECK(false, "Unexpected number of inputs for aten::randperm: ", num_inputs);
     }
     if (n == 0) {
-    return {context.mark_node(v0::Constant::create(element::i64, Shape{0},std::vector<int64_t>{}))};}
+        auto const_empty = std::make_shared<v0::Constant>(element::i64, Shape{0}, std::vector<int64_t>{});
+        return {context.mark_node(const_empty)};
+    }
     auto shape = v0::Constant::create(element::i64, Shape{1}, {n});
     auto min_val = v0::Constant::create(element::f32, Shape{}, {0.0f});
     auto max_val = v0::Constant::create(element::f32, Shape{}, {1.0f});
     auto random_tensor = context.mark_node(std::make_shared<v8::RandomUniform>(shape, min_val, max_val, element::f32));
     const int64_t axis = 0;
     auto k = v0::Constant::create(element::i64, Shape{}, {n});
-    auto topk = context.mark_node(std::make_shared<v11::TopK>(random_tensor, k, axis, ov::op::TopKMode::MIN, ov::op::TopKSortType::SORT_VALUES, element::i64, false));
+    auto topk = context.mark_node(std::make_shared<v11::TopK>(random_tensor,
+                                                              k,
+                                                              axis,
+                                                              ov::op::TopKMode::MIN,
+                                                              ov::op::TopKSortType::SORT_VALUES,
+                                                              element::i64,
+                                                              false));
     return {topk->output(1)};
 }
 

tests/layer_tests/pytorch_tests/test_polar.py

@@ -1,39 +1,44 @@
 # Copyright (C) 2018-2025 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
+import numpy as np
 import pytest
 import torch
-import numpy as np
+
 from pytorch_layer_test_class import PytorchLayerTest
 
 class TestPolar(PytorchLayerTest):
     def _prepare_input(self):
         return (
-            np.array([1.0, 2.0, 3.0], dtype=np.float32),
-            np.array([0.1, 0.2, 0.3], dtype=np.float32)
+            np.random.uniform(0, 10, (1, 1000)).astype(np.float32),
+            np.random.uniform(-np.pi, np.pi, (1, 1000)).astype(np.float32)
         )
 
     def create_model(self):
         class PolarModel(torch.nn.Module):
             def forward(self, abs, angle):
-                real = abs * torch.cos(angle)
-                imag = abs * torch.sin(angle)
-                return torch.stack([real, imag], dim=-1)
-        return PolarModel(), None, None
+                complex_tensor = torch.polar(abs, angle)
+                return torch.view_as_real(complex_tensor)
 
+        return PolarModel(), None, "aten::polar"
+
+    @pytest.mark.parametrize("input_case", [
+        (1, 1000),  
+        (2, 500),     
+        (5, 200),     
+        (10, 100),   
+    ])
+    @pytest.mark.parametrize("dtype", [
+        np.float32,
+        np.float64
+    ])
     @pytest.mark.nightly
     @pytest.mark.precommit
-    @pytest.mark.parametrize("input_variant", ["static", "dynamic"])
-    def test_polar(self, ie_device, precision, ir_version, input_variant):
-        atol = 1e-4 if precision == "FP32" else 1e-3
-        rtol = 1e-4
-        if input_variant == "static":
-            input_data = self._prepare_input()
-        else:
-            static_input = self._prepare_input()
-            input_data = (
-                np.expand_dims(static_input[0], axis=0),
-                np.expand_dims(static_input[1], axis=0)
-            )
-        self._test(*self.create_model(), ie_device, precision, ir_version,
-                   input_data=input_data, model_trace=True, atol=atol, rtol=rtol)
+    def test_polar(self, input_case, dtype, ie_device, precision, ir_version):
+        self.input_shape = input_case
+        self._prepare_input = lambda: (
+            np.random.uniform(0, 10, input_case).astype(dtype),
+            np.random.uniform(-np.pi, np.pi, input_case).astype(dtype)
+        )
+        self._test(*self.create_model(), ie_device, precision, ir_version, trace_model=True,
+                    use_convert_model=True, kwargs_to_prepare_input={})

tests/layer_tests/pytorch_tests/test_randperm.py

@@ -1,79 +1,57 @@
-# Copyright (C) 2018-2025 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
 import pytest
 import torch
 import numpy as np
 from pytorch_layer_test_class import PytorchLayerTest, flattenize_inputs
-from copy import deepcopy
 
 class TestRandperm(PytorchLayerTest):
     def _prepare_input(self):
-        return ()
+        return (np.array([self.n], dtype=np.int64),)
 
-    def create_model(self, n):
-        class AtenRandperm(torch.nn.Module):
-            def __init__(self, n):
+    def create_model(self, n, num_inputs, dtype_value=None):
+        class aten_randperm(torch.nn.Module):
+            def __init__(self, n, num_inputs, dtype_value):
                 super().__init__()
-                self.n = n
-
-            def forward(self):
-                return torch.randperm(self.n, dtype=torch.int64)
-
-        return AtenRandperm(n), None, "aten::randperm"
-
-    def is_valid_permutation(self, output, n):
-        if hasattr(output, 'detach'):
-            arr = output.detach().cpu().numpy().astype(np.int64)
-        else:
-            arr = np.array(output, dtype=np.int64)
-        sorted_arr = np.sort(arr.flatten())
-        expected = np.arange(n, dtype=np.int64)
-        return np.array_equal(sorted_arr, expected)
-
-    @pytest.mark.parametrize("n", [1, 5, 10])
+                self.n = torch.tensor(n, dtype=torch.int64)
+                self.num_inputs = num_inputs
+                self.dtype = torch.int64 if dtype_value == 4 else None
+            
+            def forward(self, x):
+                if self.num_inputs == 1:
+                    return torch.randperm(self.n)
+                elif self.num_inputs == 2:
+                    return torch.randperm(self.n, dtype=self.dtype)
+                elif self.num_inputs == 5:
+                    return torch.randperm(self.n, dtype=self.dtype, layout=torch.strided, 
+                                          device=x.device, pin_memory=False)
+                raise ValueError("Invalid num_inputs")
+        
+        return aten_randperm(n, num_inputs, dtype_value), None, "aten::randperm"
+
+    @pytest.mark.parametrize(("n", "num_inputs", "dtype_value"), [
+        (0, 1, None),
+        (1, 1, None),
+        (5, 1, None),
+        (5, 2, 4),
+        (5, 5, 4),
+    ])
     @pytest.mark.nightly
     @pytest.mark.precommit
-    def test_randperm_custom(self, n, ie_device, precision, ir_version):
-        model, ref_net, op = self.create_model(n)
+    def test_randperm(self, n, num_inputs, dtype_value, ie_device, precision, ir_version):
+        self.n = n
+        model, ref_net, op = self.create_model(n, num_inputs, dtype_value)
         inputs = self._prepare_input()
         torch_inputs = [torch.from_numpy(x) if isinstance(x, np.ndarray) else x for x in inputs]
         ov_inputs = flattenize_inputs(inputs)
-        trace_model = True
-        dynamic_shapes = True
-        freeze_model = True
-
-        with torch.no_grad():
-            smodel, converted_model = self.convert_directly_via_frontend(
-                model, torch_inputs, trace_model, dynamic_shapes, ov_inputs, freeze_model
-            )
-
-        from openvino import Core
-        core = Core()
-        compiled_model = core.compile_model(converted_model, ie_device).
-        ov_output_dict = compiled_model(())
-        ov_output_tensor = list(ov_output_dict.values())[0]
-
-        assert ov_output_tensor.shape[0] == n, f"Output shape {ov_output_tensor.shape} does not match expected ({n},)"
-        assert self.is_valid_permutation(ov_output_tensor, n), (
-            f"Output {ov_output_tensor} is not a valid permutation of [0, 1, ..., {n-1}]"
+        smodel, converted_model = self.convert_directly_via_frontend(
+            model, torch_inputs, trace_model=True, dynamic_shapes=False, ov_inputs=ov_inputs, freeze_model=True
         )
-
-    @pytest.mark.xfail(reason="OpenVINO doesn't support empty tensors for randperm")
-    def test_randperm_zero(self, ie_device, precision, ir_version):
-        model, ref_net, op = self.create_model(0)
-        inputs = self._prepare_input()
-        torch_inputs = [torch.from_numpy(x) if isinstance(x, np.ndarray) else x for x in inputs]
-        ov_inputs = flattenize_inputs(inputs)
-        trace_model = True
-        dynamic_shapes = True
-        freeze_model = True
-
-        with torch.no_grad():
-            smodel, converted_model = self.convert_directly_via_frontend(
-                model, torch_inputs, trace_model, dynamic_shapes, ov_inputs, freeze_model
-            )
         from openvino import Core
         core = Core()
         compiled_model = core.compile_model(converted_model, ie_device)
-        _ = compiled_model(())
+        
+        ov_output = compiled_model(ov_inputs)[0]
+        if n > 0:
+            assert ov_output.shape[0] == n, f"Output shape {ov_output.shape} does not match expected ({n},)"
+            assert np.array_equal(np.sort(ov_output), np.arange(n)), f"Output is not a valid permutation of [0, ..., {n-1}]"
+        else:
+            assert ov_output.shape[0] == 0, f"Output shape for n=0 should be (0,), got {ov_output.shape}"