added support for sigmoid activation fucntion

ivy/data_classes/array/activations.py

@@ -123,7 +123,13 @@ def gelu(
         """
         return ivy.gelu(self._data, approximate=approximate, out=out)
 
-    def sigmoid(self: ivy.Array, /, *, out: Optional[ivy.Array] = None) -> ivy.Array:
+    def sigmoid(
+        self: ivy.Array,
+        /,
+        *,
+        out: Optional[ivy.Array] = None,
+        complex_mode: Literal["split", "magnitude", "jax"] = "jax",
+    ) -> ivy.Array:
         """
         ivy.Array instance method variant of ivy.sigmoid.
 
@@ -137,6 +143,9 @@ def sigmoid(self: ivy.Array, /, *, out: Optional[ivy.Array] = None) -> ivy.Array
         out
             optional output array for writing the result to. It must have the same shape
             the input broadcast to default: None
+        complex_mode
+            optional specifier for how to handle complex data types. See
+            ``ivy.func_wrapper.handle_complex_input`` for more detail.
 
         Returns
         -------
@@ -151,7 +160,7 @@ def sigmoid(self: ivy.Array, /, *, out: Optional[ivy.Array] = None) -> ivy.Array
         >>> print(y)
         ivy.array([0.269, 0.731, 0.881])
         """
-        return ivy.sigmoid(self._data, out=out)
+        return ivy.sigmoid(self._data, out=out, complex_mode=complex_mode)
 
     def softmax(
         self: ivy.Array,
@@ -300,7 +309,13 @@ def mish(self: ivy.Array, /, *, out: Optional[ivy.Array] = None) -> ivy.Array:
         """
         return ivy.mish(self._data, out=out)
 
-    def hardswish(self: ivy.Array, /, *, out: Optional[ivy.Array] = None) -> ivy.Array:
+    def hardswish(
+        self: ivy.Array,
+        /,
+        *,
+        out: Optional[ivy.Array] = None,
+        complex_mode: Literal["split", "magnitude", "jax"] = "jax",
+    ) -> ivy.Array:
         """
         Apply the hardswish activation function element-wise.
 
@@ -311,6 +326,9 @@ def hardswish(self: ivy.Array, /, *, out: Optional[ivy.Array] = None) -> ivy.Arr
         out
             optional output array, for writing the result to. It must have
             a shape that the inputs broadcast to.
+        complex_mode
+            optional specifier for how to handle complex data types. See
+            ``ivy.func_wrapper.handle_complex_input`` for more detail.
 
         Returns
         -------
@@ -336,4 +354,4 @@ def hardswish(self: ivy.Array, /, *, out: Optional[ivy.Array] = None) -> ivy.Arr
             b: ivy.array([0., 5.])
         }
         """
-        return ivy.hardswish(self._data, out=out)
+        return ivy.hardswish(self._data, out=out, complex_mode=complex_mode)

ivy/data_classes/array/experimental/activations.py

@@ -1,6 +1,6 @@
 # global
 import abc
-from typing import Optional, Union
+from typing import Optional, Union, Literal
 
 # local
 import ivy
@@ -115,7 +115,13 @@ def prelu(
         """
         return ivy.prelu(self._data, slope, out=out)
 
-    def relu6(self, /, *, out: Optional[ivy.Array] = None) -> ivy.Array:
+    def relu6(
+        self,
+        /,
+        *,
+        out: Optional[ivy.Array] = None,
+        complex_mode: Literal["split", "magnitude", "jax"] = "jax",
+    ) -> ivy.Array:
         """
         Apply the rectified linear unit 6 function element-wise.
 
@@ -126,6 +132,9 @@ def relu6(self, /, *, out: Optional[ivy.Array] = None) -> ivy.Array:
         out
             optional output array, for writing the result to.
             It must have a shape that the inputs broadcast to.
+        complex_mode
+            optional specifier for how to handle complex data types. See
+            ``ivy.func_wrapper.handle_complex_input`` for more detail.
 
         Returns
         -------
@@ -148,10 +157,11 @@ def relu6(self, /, *, out: Optional[ivy.Array] = None) -> ivy.Array:
         >>> print(y)
         ivy.array([0., 0., 1., 2., 3., 4., 5., 6., 6.])
         """
-        return ivy.relu6(self._data, out=out)
+        return ivy.relu6(self._data, out=out, complex_mode=complex_mode)
 
     def logsigmoid(
         self: ivy.Array,
+        complex_mode: Literal["split", "magnitude", "jax"] = "jax",
     ) -> ivy.Array:
         """
         ivy.Array instance method variant of ivy.logsigmoid. This method simply wraps
@@ -162,6 +172,9 @@ def logsigmoid(
         ----------
         self
             Input array.
+        complex_mode
+            optional specifier for how to handle complex data types. See
+            ``ivy.func_wrapper.handle_complex_input`` for more detail.
 
         Returns
         -------
@@ -179,9 +192,15 @@ def logsigmoid(
         >>> print(z)
         ivy.array([-2.57888985, -0.31326169, -0.69314718, -0.01104775])
         """
-        return ivy.logsigmoid(self._data)
+        return ivy.logsigmoid(self._data, complex_mode=complex_mode)
 
-    def selu(self, /, *, out: Optional[ivy.Array] = None) -> ivy.Array:
+    def selu(
+        self,
+        /,
+        *,
+        out: Optional[ivy.Array] = None,
+        complex_mode: Literal["split", "magnitude", "jax"] = "jax",
+    ) -> ivy.Array:
         """
         Apply the scaled exponential linear unit function element-wise.
 
@@ -192,6 +211,9 @@ def selu(self, /, *, out: Optional[ivy.Array] = None) -> ivy.Array:
         out
             optional output array, for writing the result to.
             It must have a shape that the inputs broadcast to.
+        complex_mode
+            optional specifier for how to handle complex data types. See
+            ``ivy.func_wrapper.handle_complex_input`` for more detail.
 
         Returns
         -------
@@ -216,9 +238,15 @@ def selu(self, /, *, out: Optional[ivy.Array] = None) -> ivy.Array:
         ivy.array([-1.11133075,  0.,  1.05070102,  2.10140204,  3.15210295,
                     4.20280409,  5.25350523,  6.30420589,  7.35490704])
         """
-        return ivy.selu(self._data, out=out)
+        return ivy.selu(self._data, out=out, complex_mode=complex_mode)
 
-    def silu(self: ivy.Array, /, *, out: Optional[ivy.Array] = None) -> ivy.Array:
+    def silu(
+        self: ivy.Array,
+        /,
+        *,
+        out: Optional[ivy.Array] = None,
+        complex_mode: Literal["split", "magnitude", "jax"] = "jax",
+    ) -> ivy.Array:
         """
         ivy.Array instance method variant of ivy.silu. This method simply wraps the
         function, and so the docstring for ivy.silu also applies to this method with
@@ -231,6 +259,9 @@ def silu(self: ivy.Array, /, *, out: Optional[ivy.Array] = None) -> ivy.Array:
         out
             optional output array, for writing the result to. It must have a shape
             that the inputs broadcast to.
+        complex_mode
+            optional specifier for how to handle complex data types. See
+            ``ivy.func_wrapper.handle_complex_input`` for more detail.
 
         Examples
         --------
@@ -239,14 +270,15 @@ def silu(self: ivy.Array, /, *, out: Optional[ivy.Array] = None) -> ivy.Array:
         >>> print(y)
         ivy.array([-0.26894143,  0.        ,  0.73105854])
         """
-        return ivy.silu(self._data, out=out)
+        return ivy.silu(self._data, out=out, complex_mode=complex_mode)
 
     def elu(
         self,
         /,
         *,
         alpha: float = 1.0,
         out: Optional[ivy.Array] = None,
+        complex_mode: Literal["split", "magnitude", "jax"] = "jax",
     ) -> ivy.Array:
         """
         Ivy.Array instance method variant of ivy.elu. This method simply wraps the
@@ -262,6 +294,9 @@ def elu(
         out
             optional output array, for writing the result to. It must have a shape
             that the inputs broadcast to.
+        complex_mode
+            optional specifier for how to handle complex data types. See
+            ``ivy.func_wrapper.handle_complex_input`` for more detail.
 
         Returns
         -------
@@ -275,4 +310,4 @@ def elu(
         >>> print(y)
         ivy.array([ 0.39, -0.57])
         """
-        return ivy.elu(self._data, alpha=alpha, out=out)
+        return ivy.elu(self._data, alpha=alpha, out=out, complex_mode=complex_mode)

ivy/data_classes/container/activations.py

@@ -414,6 +414,7 @@ def _static_sigmoid(
         prune_unapplied: Union[bool, ivy.Container] = False,
         map_sequences: Union[bool, ivy.Container] = False,
         out: Optional[ivy.Container] = None,
+        complex_mode: Literal["split", "magnitude", "jax"] = "jax",
     ) -> ivy.Container:
         """
         ivy.Container static method variant of ivy.sigmoid. This method simply wraps the
@@ -438,6 +439,9 @@ def _static_sigmoid(
         out
             optional output container, for writing the result to. It must have a shape
             that the inputs broadcast to.
+        complex_mode
+            optional specifier for how to handle complex data types. See
+            ``ivy.func_wrapper.handle_complex_input`` for more detail.
 
         Returns
         -------
@@ -462,6 +466,7 @@ def _static_sigmoid(
             prune_unapplied=prune_unapplied,
             map_sequences=map_sequences,
             out=out,
+            complex_mode=complex_mode,
         )
 
     def sigmoid(
@@ -473,6 +478,7 @@ def sigmoid(
         prune_unapplied: Union[bool, ivy.Container] = False,
         map_sequences: Union[bool, ivy.Container] = False,
         out: Optional[ivy.Container] = None,
+        complex_mode: Literal["split", "magnitude", "jax"] = "jax",
     ) -> ivy.Container:
         """
         ivy.Container instance method variant of ivy.sigmoid. This method simply wraps
@@ -497,6 +503,9 @@ def sigmoid(
         out
             optional output container, for writing the result to. It must have a shape
             that the inputs broadcast to.
+        complex_mode
+            optional specifier for how to handle complex data types. See
+            ``ivy.func_wrapper.handle_complex_input`` for more detail.
 
         Returns
         -------
@@ -520,6 +529,7 @@ def sigmoid(
             prune_unapplied=prune_unapplied,
             map_sequences=map_sequences,
             out=out,
+            complex_mode=complex_mode,
         )
 
     @staticmethod
@@ -1065,6 +1075,7 @@ def _static_hardswish(
         prune_unapplied: Union[bool, ivy.Container] = False,
         map_sequences: Union[bool, ivy.Container] = False,
         out: Optional[ivy.Container] = None,
+        complex_mode: Literal["split", "magnitude", "jax"] = "jax",
     ) -> ivy.Container:
         """
         ivy.Container static method variant of ivy.hardswish. This method simply wraps
@@ -1089,6 +1100,9 @@ def _static_hardswish(
         out
             optional output container, for writing the result to. It must have a shape
             that the inputs broadcast to.
+        complex_mode
+            optional specifier for how to handle complex data types. See
+            ``ivy.func_wrapper.handle_complex_input`` for more detail.
 
         Returns
         -------
@@ -1114,6 +1128,7 @@ def _static_hardswish(
             prune_unapplied=prune_unapplied,
             map_sequences=map_sequences,
             out=out,
+            complex_mode=complex_mode,
         )
 
     def hardswish(
@@ -1125,6 +1140,7 @@ def hardswish(
         prune_unapplied: Union[bool, ivy.Container] = False,
         map_sequences: Union[bool, ivy.Container] = False,
         out: Optional[ivy.Container] = None,
+        complex_mode: Literal["split", "magnitude", "jax"] = "jax",
     ) -> ivy.Container:
         """
         ivy.Container instance method variant of ivy.hardswish. This method simply wraps
@@ -1149,6 +1165,9 @@ def hardswish(
         out
             optional output container, for writing the result to. It must have a shape
             that the inputs broadcast to.
+        complex_mode
+            optional specifier for how to handle complex data types. See
+            ``ivy.func_wrapper.handle_complex_input`` for more detail.
 
         Returns
         -------
@@ -1173,4 +1192,5 @@ def hardswish(
             prune_unapplied=prune_unapplied,
             map_sequences=map_sequences,
             out=out,
+            complex_mode=complex_mode,
         )