Merge branch 'paddle_repeat_interleave' of https://github.com/dhanush…

…-2501/ivy into paddle_repeat_interleave

.pre-commit-config.yaml

@@ -7,7 +7,7 @@ repos:
         args:
           - "--preview"
   - repo: https://github.com/PyCQA/autoflake
-    rev: v2.2.0
+    rev: v2.2.1
     hooks:
       - id: autoflake
   - repo: https://github.com/pycqa/flake8

docs/index.rst

@@ -10,16 +10,14 @@
 
   overview/get_started.rst
   Examples <demos/index.rst>
-  overview/glossary.rst
-  overview/faq.rst
 
 
 .. toctree::
   :hidden:
   :maxdepth: -1
-  :caption: Users
+  :caption: Background
 
-  overview/background.rst
+  overview/motivation.rst
   overview/related_work.rst
   overview/extensions.rst
 
@@ -32,6 +30,8 @@
   overview/design.rst
   overview/contributing.rst
   overview/deep_dive.rst
+  overview/glossary.rst
+  overview/faq.rst
 
 
 .. toctree::

docs/overview/background.rst → docs/overview/motivation.rst

@@ -1,4 +1,4 @@
-Background
+Motivation
 ==========
 
 | (a) :ref:`ML Explosion`
@@ -15,6 +15,6 @@ Background
    :maxdepth: -1
    :caption: Background
 
-   background/ml_explosion.rst
-   background/why_unify.rst
-   background/standardization.rst
+   motivation/ml_explosion.rst
+   motivation/why_unify.rst
+   motivation/standardization.rst

install_dependencies.sh

@@ -1,3 +1,4 @@
+sudo apt-get update
 sudo apt-get install pandoc -y
 pip install -r requirements/requirements.txt
 if [[ $(arch) == 'arm64' ]]; then

ivy/data_classes/array/conversions.py

@@ -53,7 +53,7 @@ def _to_ivy(x: Any) -> Any:
 def to_ivy(
     x: Union[ivy.Array, ivy.NativeArray, Iterable],
     nested: bool = False,
-    include_derived: Optional[Dict[type, bool]] = None,
+    include_derived: Optional[Dict[str, bool]] = None,
 ) -> Union[ivy.Array, ivy.NativeArray, Iterable]:
     """
     Return the input array converted to an ivy.Array instance if it is a native array
@@ -84,7 +84,7 @@ def to_ivy(
 
 def args_to_ivy(
     *args: Iterable[Any],
-    include_derived: Optional[Dict[type, bool]] = None,
+    include_derived: Optional[Dict[str, bool]] = None,
     **kwargs: Dict[str, Any],
 ) -> Tuple[Iterable[Any], Dict[str, Any]]:
     """
@@ -115,7 +115,7 @@ def args_to_ivy(
 def to_native(
     x: Union[ivy.Array, ivy.NativeArray, Iterable],
     nested: bool = False,
-    include_derived: Optional[Dict[type, bool]] = None,
+    include_derived: Optional[Dict[str, bool]] = None,
     cont_inplace: bool = False,
     to_ignore: Optional[Union[type, Tuple[type]]] = None,
 ) -> Union[ivy.Array, ivy.NativeArray, Iterable]:
@@ -157,7 +157,7 @@ def to_native(
 
 def args_to_native(
     *args: Iterable[Any],
-    include_derived: Dict[type, bool] = None,
+    include_derived: Dict[str, bool] = None,
     cont_inplace: bool = False,
     to_ignore: Optional[Union[type, Tuple[type]]] = None,
     **kwargs: Dict[str, Any],

ivy/data_classes/array/experimental/linear_algebra.py

@@ -728,3 +728,59 @@ def dot(
         ivy.array([[-15.28]])
         """
         return ivy.dot(self._data, b, out=out)
+
+    def general_inner_product(
+        self: Union[ivy.Array, ivy.NativeArray],
+        b: Union[ivy.Array, ivy.NativeArray],
+        n_modes: Optional[int] = None,
+        /,
+        *,
+        out: Optional[ivy.Array] = None,
+    ) -> ivy.Array:
+        """
+        ivy.Array instance method variant of ivy.general_inner_product. This method
+        simply wraps the function, and so the docstring for ivy.general_inner_product
+        also applies to this method with minimal changes.
+
+        Parameters
+        ----------
+        self
+            first input tensor.
+        b
+            second input tensor.
+        n_modes
+            int, default is None. If None, the traditional inner product is returned
+            (i.e. a float) otherwise, the product between the `n_modes` last modes of
+            `a` and the `n_modes` first modes of `b` is returned. The resulting tensor's
+            order is `len(a) - n_modes`.
+        out
+            Optional output array. If provided, the output array to store the result.
+
+        Returns
+        -------
+            The inner product of the input arrays.
+
+        Examples
+        --------
+        With :class:`ivy.Array` inputs:
+
+        >>> a = ivy.array([1, 2, 3])
+        >>> b = ivy.array([4, 5, 6])
+        >>> result = a.general_inner_product(b, n_modes=1)
+        >>> print(result)
+        ivy.array(32)
+
+        >>> a = ivy.array([1, 2])
+        >>> b = ivy.array([4, 5])
+        >>> result = a.general_inner_product(b)
+        >>> print(result)
+        ivy.array(14)
+
+        >>> a = ivy.array([[1, 1], [1, 1]])
+        >>> b = ivy.array([[1, 2, 3, 4],[1, 1, 1, 1]])
+        >>> result = a.general_inner_product(b, n_modes=1)
+        >>> print(result)
+        ivy.array([[2, 3, 4, 5],
+            [2, 3, 4, 5]])
+        """
+        return ivy.general_inner_product(self, b, n_modes, out=out)

ivy/data_classes/array/general.py

@@ -988,7 +988,7 @@ def value_is_nan(self: ivy.Array, /, *, include_infs: bool = True) -> bool:
         """
         return ivy.value_is_nan(self, include_infs=include_infs)
 
-    def exists(self: ivy.Array) -> bool:
+    def exists(self: ivy.Array, /) -> bool:
         """
         ivy.Array instance method variant of ivy.exists. This method simply wraps the
         function, and so the docstring for ivy.exists also applies to this method with
@@ -1002,7 +1002,7 @@ def exists(self: ivy.Array) -> bool:
         Returns
         -------
         ret
-            True if x is not None, else False.
+            True if input is not None, else False.
 
         Examples
         --------

ivy/data_classes/array/layers.py

@@ -1,6 +1,6 @@
 # global
 import abc
-from typing import Optional, Tuple, Union, List, Sequence, Dict
+from typing import Optional, Tuple, Union, List, Sequence
 
 # local
 import ivy

ivy/data_classes/container/conversions.py

@@ -18,7 +18,7 @@ class _ContainerWithConversions(ContainerBase):
     def _static_to_native(
         x: Union[ivy.Array, ivy.NativeArray, ivy.Container],
         nested: Union[bool, ivy.Container] = False,
-        include_derived: Optional[Union[Dict[type, bool], ivy.Container]] = None,
+        include_derived: Optional[Union[Dict[str, bool], ivy.Container]] = None,
         key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None,
         to_apply: Union[bool, ivy.Container] = True,
         prune_unapplied: Union[bool, ivy.Container] = False,
@@ -78,7 +78,7 @@ def _static_to_native(
     def to_native(
         self: ivy.Container,
         nested: Union[bool, ivy.Container] = False,
-        include_derived: Optional[Union[Dict[type, bool], ivy.Container]] = None,
+        include_derived: Optional[Union[Dict[str, bool], ivy.Container]] = None,
         key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None,
         to_apply: Union[bool, ivy.Container] = True,
         prune_unapplied: Union[bool, ivy.Container] = False,
@@ -138,7 +138,7 @@ def to_native(
     def _static_to_ivy(
         x: Union[ivy.Array, ivy.NativeArray, ivy.Container],
         nested: Union[bool, ivy.Container] = False,
-        include_derived: Optional[Union[Dict[type, bool], ivy.Container]] = None,
+        include_derived: Optional[Union[Dict[str, bool], ivy.Container]] = None,
         key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None,
         to_apply: Union[bool, ivy.Container] = True,
         prune_unapplied: Union[bool, ivy.Container] = False,
@@ -199,7 +199,7 @@ def _static_to_ivy(
     def to_ivy(
         self: ivy.Container,
         nested: Union[bool, ivy.Container] = False,
-        include_derived: Optional[Union[Dict[type, bool], ivy.Container]] = None,
+        include_derived: Optional[Union[Dict[str, bool], ivy.Container]] = None,
         key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None,
         to_apply: Union[bool, ivy.Container] = True,
         prune_unapplied: Union[bool, ivy.Container] = False,

ivy/data_classes/container/general.py

@@ -4245,3 +4245,127 @@ def strides(
             A tuple containing the strides.
         """
         return self.static_strides(self)
+
+    @staticmethod
+    def _static_exists(
+        x: ivy.Container,
+        /,
+        *,
+        key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None,
+        to_apply: Union[bool, ivy.Container] = True,
+        prune_unapplied: Union[bool, ivy.Container] = False,
+        map_sequences: Union[bool, ivy.Container] = False,
+    ) -> ivy.Container:
+        """
+        ivy.Container instance method variant of ivy.exists. This method simply wraps
+        the function, and so the docstring for ivy.exists also applies to this method
+        with minimal changes.
+
+        Parameters
+        ----------
+        x
+            The input container.
+        key_chains
+            The key-chains to apply or not apply the method to. Default is ``None``.
+        to_apply
+            If True, the method will be applied to key_chains, otherwise key_chains
+            will be skipped. Default is ``True``.
+        prune_unapplied
+            Whether to prune key_chains for which the function was not applied.
+            Default is ``False``.
+        map_sequences
+            Whether to also map method to sequences (lists, tuples).
+            Default is ``False``.
+
+        Returns
+        -------
+        ret
+            A boolean container detaling if any of the leaf nodes are None.
+            True if not None, False if None.
+
+        Examples
+        --------
+        >>> x = ivy.Container(a=ivy.array([0,4,5]), b=ivy.array([2,2,0]))
+        >>> y = x._static_exists(x)
+        >>> print(y)
+        { a: True, b: True }
+
+        >>> x = ivy.Container(a=[1,2], b=None)
+        >>> y = x._static_exists(x)
+        >>> print(y)
+        { a: True, b: False }
+
+        >>> x = ivy.Container(a={"d": 1, "c": 3}, b={"d": 20, "c": None})
+        >>> y = x._static_exists(x)
+        >>> print(y)
+        { a: { c: True, d: True }, b: { c: False, d: True } }
+        """
+        return ContainerBase.cont_multi_map_in_function(
+            "exists",
+            x,
+            key_chains=key_chains,
+            to_apply=to_apply,
+            prune_unapplied=prune_unapplied,
+            map_sequences=map_sequences,
+        )
+
+    def exists(
+        self: ivy.Container,
+        /,
+        *,
+        key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None,
+        to_apply: Union[bool, ivy.Container] = True,
+        prune_unapplied: Union[bool, ivy.Container] = False,
+        map_sequences: Union[bool, ivy.Container] = False,
+    ) -> ivy.Container:
+        """
+        ivy.Container instance method variant of ivy.exists. This method simply wraps
+        the function, and so the docstring for ivy.exists also applies to this method
+        with minimal changes.
+
+        Parameters
+        ----------
+        self
+            The input container.
+        key_chains
+            The key-chains to apply or not apply the method to. Default is ``None``.
+        to_apply
+            If True, the method will be applied to key_chains, otherwise key_chains
+            will be skipped. Default is ``True``.
+        prune_unapplied
+            Whether to prune key_chains for which the function was not applied.
+            Default is ``False``.
+        map_sequences
+            Whether to also map method to sequences (lists, tuples).
+            Default is ``False``.
+
+        Returns
+        -------
+        ret
+            A boolean container detaling if any of the leaf nodes are None.
+            True if not None, False if None.
+
+        Examples
+        --------
+        >>> x = ivy.Container(a=[1,2,3,4], b=[])
+        >>> y = x.exists()
+        >>> print(y)
+        { a: True, b: True }
+
+        >>> x = ivy.Container(a=None, b=[1,2])
+        >>> y = x.exists()
+        >>> print(y)
+        { a: False, b: True }
+
+        >>> x = ivy.Container(a={"d": 1, "c": 3}, b=None)
+        >>> y = x.exists()
+        >>> print(y)
+        { a: { c: True, d: True }, b: False }
+        """
+        return self._static_exists(
+            self,
+            key_chains=key_chains,
+            to_apply=to_apply,
+            prune_unapplied=prune_unapplied,
+            map_sequences=map_sequences,
+        )