docstr: ivy.Container static method variant of ivy.vander. This method
  simply wraps the function, and so the docstring for ivy.vander also
  applies to this method with minimal changes.
  
  Parameters
  ----------
  x
      ivy container that contains 1-D arrays.
  N
      Number of columns in the output. If N is not specified,
      a square array is returned (N = len(x))
  increasing
      Order of the powers of the columns. If True, the powers increase
      from left to right, if False (the default) they are reversed.
  out
      optional output container, for writing the result to.
  
  Returns
  -------
  ret
      container that contains the Vandermonde matrix of the arrays included
      in the input container.
  
  Examples
  --------
  With :class:`ivy.Container` inputs:
  
  >>> x = ivy.Container(
          a = ivy.array([1, 2, 3, 5])
          b = ivy.array([6, 7, 8, 9])
      )
  >>> ivy.Container.static_vander(x)
  {
      a: ivy.array(
              [[  1,   1,   1,   1],
              [  8,   4,   2,   1],
              [ 27,   9,   3,   1],
              [125,  25,   5,   1]]
              ),
      b: ivy.array(
              [[216,  36,   6,   1],
              [343,  49,   7,   1],
              [512,  64,   8,   1],
              [729,  81,   9,   1]]
              )
  }
code: def _static_vander(
      x: Union[ivy.Array, ivy.NativeArray, ivy.Container],
      /,
      *,
      N: Optional[Union[int, ivy.Container]] = None,
      increasing: Union[bool, ivy.Container] = False,
      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,
      out: Optional[ivy.Container] = None,
  ) -> ivy.Container:
      """ivy.Container static method variant of ivy.vander. This method
      simply wraps the function, and so the docstring for ivy.vander also
      applies to this method with minimal changes.
  
      Parameters
      ----------
      x
          ivy container that contains 1-D arrays.
      N
          Number of columns in the output. If N is not specified,
          a square array is returned (N = len(x))
      increasing
          Order of the powers of the columns. If True, the powers increase
          from left to right, if False (the default) they are reversed.
      out
          optional output container, for writing the result to.
  
      Returns
      -------
      ret
          container that contains the Vandermonde matrix of the arrays included
          in the input container.
  
      Examples
      --------
      With :class:`ivy.Container` inputs:
  
      >>> x = ivy.Container(
              a = ivy.array([1, 2, 3, 5])
              b = ivy.array([6, 7, 8, 9])
          )
      >>> ivy.Container.static_vander(x)
      {
          a: ivy.array(
                  [[  1,   1,   1,   1],
                  [  8,   4,   2,   1],
                  [ 27,   9,   3,   1],
                  [125,  25,   5,   1]]
                  ),
          b: ivy.array(
                  [[216,  36,   6,   1],
                  [343,  49,   7,   1],
                  [512,  64,   8,   1],
                  [729,  81,   9,   1]]
                  )
      }
      """
      return ContainerBase.cont_multi_map_in_function(
          "vander",
          x,
          N=N,
          increasing=increasing,
          key_chains=key_chains,
          to_apply=to_apply,
          prune_unapplied=prune_unapplied,
          map_sequences=map_sequences,
          out=out,
      )
  
imports: from typing import Union, Optional, Tuple, Literal, List, Dict, Sequence
  from ivy.data_classes.container.base import ContainerBase
  import ivy
label_desc: Use image node_id 55 for calling the _ContainerWithLinearAlgebra obj's underlying member method code with example usage: obj._static_vander() and returns: ContainerBase