Adding Cos, Sin, Acos, Sigmoid to PyTorch Frontend

ivy/functional/frontends/torch/__init__.py

@@ -3,5 +3,7 @@
 from .indexing_slicing_joining_mutating_ops import *
 from . import pointwise_ops
 from .pointwise_ops import *
+from . import non_linear_activation_functions
+from .non_linear_activation_functions import *
 from . import creation_ops
 from .creation_ops import *

ivy/functional/frontends/torch/non_linear_activation_functions.py

@@ -0,0 +1,9 @@
+# global
+import ivy
+
+
+def sigmoid(input, out=None):
+    return ivy.sigmoid(input, out=out)
+
+
+sigmoid.unsupported_dtypes = ("float16",)

ivy/functional/frontends/torch/pointwise_ops.py

@@ -16,5 +16,26 @@ def tan(input, *, out=None):
 tan.unsupported_dtypes = ("float16",)
 
 
+def cos(input, *, out=None):
+    return ivy.cos(input, out=out)
+
+
+cos.unsupported_dtypes = ("float16",)
+
+
+def sin(input, *, out=None):
+    return ivy.sin(input, out=out)
+
+
+sin.unsupported_dtypes = ("float16",)
+
+
+def acos(input, *, out=None):
+    return ivy.acos(input, out=out)
+
+
+acos.unsupported_dtypes = ("float16",)
+
+
 def abs(input, *, out=None):
     return ivy.abs(input, out=out)

ivy_tests/test_ivy/test_frontends/test_torch/test_non_linear_activation_functions.py

@@ -0,0 +1,45 @@
+# global
+import numpy as np
+from hypothesis import given, strategies as st
+
+# local
+import ivy_tests.test_ivy.helpers as helpers
+import ivy.functional.backends.numpy as ivy_np
+import ivy.functional.backends.torch as ivy_torch
+
+
+@given(
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=tuple(
+            set(ivy_np.valid_float_dtypes).intersection(
+                set(ivy_torch.valid_float_dtypes)
+            )
+        )
+    ),
+    as_variable=st.booleans(),
+    with_out=st.booleans(),
+    num_positional_args=helpers.num_positional_args(fn_name="sigmoid"),
+    native_array=st.booleans(),
+)
+def test_torch_sigmoid(
+    dtype_and_x,
+    as_variable,
+    with_out,
+    num_positional_args,
+    native_array,
+    fw,
+):
+    input_dtype, x = dtype_and_x
+
+    helpers.test_frontend_function(
+        input_dtypes=input_dtype,
+        as_variable_flags=as_variable,
+        with_out=with_out,
+        num_positional_args=num_positional_args,
+        native_array_flags=native_array,
+        fw=fw,
+        frontend="torch",
+        fn_name="sigmoid",
+        input=np.asarray(x, dtype=input_dtype),
+        out=None,
+    )

ivy_tests/test_ivy/test_frontends/test_torch/test_pointwise_ops.py

@@ -127,3 +127,120 @@ def test_torch_abs(
         input=np.asarray(x, dtype=input_dtype),
         out=None,
     )
+
+
+# cos
+@given(
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=tuple(
+            set(ivy_np.valid_float_dtypes).intersection(
+                set(ivy_torch.valid_float_dtypes)
+            )
+        )
+    ),
+    as_variable=st.booleans(),
+    with_out=st.booleans(),
+    num_positional_args=helpers.num_positional_args(
+        fn_name="functional.frontends.torch.cos"
+    ),
+    native_array=st.booleans(),
+)
+def test_torch_cos(
+    dtype_and_x,
+    as_variable,
+    with_out,
+    num_positional_args,
+    native_array,
+    fw,
+):
+    input_dtype, x = dtype_and_x
+    helpers.test_frontend_function(
+        input_dtypes=input_dtype,
+        as_variable_flags=as_variable,
+        with_out=with_out,
+        num_positional_args=num_positional_args,
+        native_array_flags=native_array,
+        fw=fw,
+        frontend="torch",
+        fn_name="cos",
+        input=np.asarray(x, dtype=input_dtype),
+        out=None,
+    )
+
+
+# sin
+@given(
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=tuple(
+            set(ivy_np.valid_float_dtypes).intersection(
+                set(ivy_torch.valid_float_dtypes)
+            )
+        )
+    ),
+    as_variable=st.booleans(),
+    with_out=st.booleans(),
+    num_positional_args=helpers.num_positional_args(
+        fn_name="functional.frontends.torch.sin"
+    ),
+    native_array=st.booleans(),
+)
+def test_torch_sin(
+    dtype_and_x,
+    as_variable,
+    with_out,
+    num_positional_args,
+    native_array,
+    fw,
+):
+    input_dtype, x = dtype_and_x
+    helpers.test_frontend_function(
+        input_dtypes=input_dtype,
+        as_variable_flags=as_variable,
+        with_out=with_out,
+        num_positional_args=num_positional_args,
+        native_array_flags=native_array,
+        fw=fw,
+        frontend="torch",
+        fn_name="sin",
+        input=np.asarray(x, dtype=input_dtype),
+        out=None,
+    )
+
+
+# acos
+@given(
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=tuple(
+            set(ivy_np.valid_float_dtypes).intersection(
+                set(ivy_torch.valid_float_dtypes)
+            )
+        )
+    ),
+    as_variable=st.booleans(),
+    with_out=st.booleans(),
+    num_positional_args=helpers.num_positional_args(
+        fn_name="functional.frontends.torch.acos"
+    ),
+    native_array=st.booleans(),
+)
+def test_torch_acos(
+    dtype_and_x,
+    as_variable,
+    with_out,
+    num_positional_args,
+    native_array,
+    fw,
+):
+    input_dtype, x = dtype_and_x
+    helpers.test_frontend_function(
+        input_dtypes=input_dtype,
+        as_variable_flags=as_variable,
+        with_out=with_out,
+        num_positional_args=num_positional_args,
+        native_array_flags=native_array,
+        fw=fw,
+        frontend="torch",
+        fn_name="acos",
+        input=np.asarray(x, dtype=input_dtype),
+        out=None,
+    )