files: import numpy as np
  
  def arange(start, /, *, stop=None, step=1, dtype=None, device=None):
      if device is not None:
          # Note: Device support is not yet implemented on ndarray
          raise NotImplementedError("Device support is not yet implemented")
      return np.arange(start, stop=stop, step=step, dtype=dtype)
  
  def empty(shape, /, *, dtype=None, device=None):
      if device is not None:
          # Note: Device support is not yet implemented on ndarray
          raise NotImplementedError("Device support is not yet implemented")
      return np.empty(shape, dtype=dtype)
  
  def empty_like(x, /, *, dtype=None, device=None):
      if device is not None:
          # Note: Device support is not yet implemented on ndarray
          raise NotImplementedError("Device support is not yet implemented")
      return np.empty_like(x, dtype=dtype)
  
  def eye(N, /, *, M=None, k=0, dtype=None, device=None):
      if device is not None:
          # Note: Device support is not yet implemented on ndarray
          raise NotImplementedError("Device support is not yet implemented")
      return np.eye(N, M=M, k=k, dtype=dtype)
  
  def full(shape, fill_value, /, *, dtype=None, device=None):
      if device is not None:
          # Note: Device support is not yet implemented on ndarray
          raise NotImplementedError("Device support is not yet implemented")
      return np.full(shape, fill_value, dtype=dtype)
  
  def full_like(x, fill_value, /, *, dtype=None, device=None):
      if device is not None:
          # Note: Device support is not yet implemented on ndarray
          raise NotImplementedError("Device support is not yet implemented")
      return np.full_like(x, fill_value, dtype=dtype)
  
  def linspace(start, stop, num, /, *, dtype=None, device=None, endpoint=True):
      if device is not None:
          # Note: Device support is not yet implemented on ndarray
          raise NotImplementedError("Device support is not yet implemented")
      return np.linspace(start, stop, num, dtype=dtype, endpoint=endpoint)
  
  def ones(shape, /, *, dtype=None, device=None):
      if device is not None:
          # Note: Device support is not yet implemented on ndarray
          raise NotImplementedError("Device support is not yet implemented")
      return np.ones(shape, dtype=dtype)
  
  def ones_like(x, /, *, dtype=None, device=None):
      if device is not None:
          # Note: Device support is not yet implemented on ndarray
          raise NotImplementedError("Device support is not yet implemented")
      return np.ones_like(x, dtype=dtype)
  
  def zeros(shape, /, *, dtype=None, device=None):
      if device is not None:
          # Note: Device support is not yet implemented on ndarray
          raise NotImplementedError("Device support is not yet implemented")
      return np.zeros(shape, dtype=dtype)
  
  def zeros_like(x, /, *, dtype=None, device=None):
      if device is not None:
          # Note: Device support is not yet implemented on ndarray
          raise NotImplementedError("Device support is not yet implemented")
      return np.zeros_like(x, dtype=dtype)
  
files: numpy/_array_api/_creation_functions.py
files: def arange(start, /, *, stop=None, step=1, dtype=None, device=None):
      from .. import arange
      if device is not None:
          # Note: Device support is not yet implemented on ndarray
          raise NotImplementedError("Device support is not yet implemented")
      return arange(start, stop=stop, step=step, dtype=dtype)
  
  def empty(shape, /, *, dtype=None, device=None):
      from .. import empty
      if device is not None:
          # Note: Device support is not yet implemented on ndarray
          raise NotImplementedError("Device support is not yet implemented")
      return empty(shape, dtype=dtype)
  
  def empty_like(x, /, *, dtype=None, device=None):
      from .. import empty_like
      if device is not None:
          # Note: Device support is not yet implemented on ndarray
          raise NotImplementedError("Device support is not yet implemented")
      return empty_like(x, dtype=dtype)
  
  def eye(N, /, *, M=None, k=0, dtype=None, device=None):
      from .. import eye
      if device is not None:
          # Note: Device support is not yet implemented on ndarray
          raise NotImplementedError("Device support is not yet implemented")
      return eye(N, M=M, k=k, dtype=dtype)
  
  def full(shape, fill_value, /, *, dtype=None, device=None):
      from .. import full
      if device is not None:
          # Note: Device support is not yet implemented on ndarray
          raise NotImplementedError("Device support is not yet implemented")
      return full(shape, fill_value, dtype=dtype)
  
  def full_like(x, fill_value, /, *, dtype=None, device=None):
      from .. import full_like
      if device is not None:
          # Note: Device support is not yet implemented on ndarray
          raise NotImplementedError("Device support is not yet implemented")
      return full_like(x, fill_value, dtype=dtype)
  
  def linspace(start, stop, num, /, *, dtype=None, device=None, endpoint=True):
      from .. import linspace
      if device is not None:
          # Note: Device support is not yet implemented on ndarray
          raise NotImplementedError("Device support is not yet implemented")
      return linspace(start, stop, num, dtype=dtype, endpoint=endpoint)
  
  def ones(shape, /, *, dtype=None, device=None):
      from .. import ones
      if device is not None:
          # Note: Device support is not yet implemented on ndarray
          raise NotImplementedError("Device support is not yet implemented")
      return ones(shape, dtype=dtype)
  
  def ones_like(x, /, *, dtype=None, device=None):
      from .. import ones_like
      if device is not None:
          # Note: Device support is not yet implemented on ndarray
          raise NotImplementedError("Device support is not yet implemented")
      return ones_like(x, dtype=dtype)
  
  def zeros(shape, /, *, dtype=None, device=None):
      from .. import zeros
      if device is not None:
          # Note: Device support is not yet implemented on ndarray
          raise NotImplementedError("Device support is not yet implemented")
      return zeros(shape, dtype=dtype)
  
  def zeros_like(x, /, *, dtype=None, device=None):
      from .. import zeros_like
      if device is not None:
          # Note: Device support is not yet implemented on ndarray
          raise NotImplementedError("Device support is not yet implemented")
      return zeros_like(x, dtype=dtype)
  
files: numpy/_array_api/_creation_functions.py
files: import numpy as np
  
  def abs(x, /):
      return np.abs(x)
  
  def acos(x, /):
      # Note: the function name is different here
      return np.arccos(x)
  
  def acosh(x, /):
      # Note: the function name is different here
      return np.arccosh(x)
  
  def add(x1, x2, /):
      return np.add(x1, x2)
  
  def asin(x, /):
      # Note: the function name is different here
      return np.arcsin(x)
  
  def asinh(x, /):
      # Note: the function name is different here
      return np.arcsinh(x)
  
  def atan(x, /):
      # Note: the function name is different here
      return np.arctan(x)
  
  def atan2(x1, x2, /):
      # Note: the function name is different here
      return np.arctan2(x1, x2)
  
  def atanh(x, /):
      # Note: the function name is different here
      return np.arctanh(x)
  
  def bitwise_and(x1, x2, /):
      return np.bitwise_and(x1, x2)
  
  def bitwise_left_shift(x1, x2, /):
      # Note: the function name is different here
      return np.left_shift(x1, x2)
  
  def bitwise_invert(x, /):
      # Note: the function name is different here
      return np.invert(x)
  
  def bitwise_or(x1, x2, /):
      return np.bitwise_or(x1, x2)
  
  def bitwise_right_shift(x1, x2, /):
      # Note: the function name is different here
      return np.right_shift(x1, x2)
  
  def bitwise_xor(x1, x2, /):
      return np.bitwise_xor(x1, x2)
  
  def ceil(x, /):
      return np.ceil(x)
  
  def cos(x, /):
      return np.cos(x)
  
  def cosh(x, /):
      return np.cosh(x)
  
  def divide(x1, x2, /):
      return np.divide(x1, x2)
  
  def equal(x1, x2, /):
      return np.equal(x1, x2)
  
  def exp(x, /):
      return np.exp(x)
  
  def expm1(x, /):
      return np.expm1(x)
  
  def floor(x, /):
      return np.floor(x)
  
  def floor_divide(x1, x2, /):
      return np.floor_divide(x1, x2)
  
  def greater(x1, x2, /):
      return np.greater(x1, x2)
  
  def greater_equal(x1, x2, /):
      return np.greater_equal(x1, x2)
  
  def isfinite(x, /):
      return np.isfinite(x)
  
  def isinf(x, /):
      return np.isinf(x)
  
  def isnan(x, /):
      return np.isnan(x)
  
  def less(x1, x2, /):
      return np.less(x1, x2)
  
  def less_equal(x1, x2, /):
      return np.less_equal(x1, x2)
  
  def log(x, /):
      return np.log(x)
  
  def log1p(x, /):
      return np.log1p(x)
  
  def log2(x, /):
      return np.log2(x)
  
  def log10(x, /):
      return np.log10(x)
  
  def logical_and(x1, x2, /):
      return np.logical_and(x1, x2)
  
  def logical_not(x, /):
      return np.logical_not(x)
  
  def logical_or(x1, x2, /):
      return np.logical_or(x1, x2)
  
  def logical_xor(x1, x2, /):
      return np.logical_xor(x1, x2)
  
  def multiply(x1, x2, /):
      return np.multiply(x1, x2)
  
  def negative(x, /):
      return np.negative(x)
  
  def not_equal(x1, x2, /):
      return np.not_equal(x1, x2)
  
  def positive(x, /):
      return np.positive(x)
  
  def pow(x1, x2, /):
      # Note: the function name is different here
      return np.power(x1, x2)
  
  def remainder(x1, x2, /):
      return np.remainder(x1, x2)
  
  def round(x, /):
      return np.round(x)
  
  def sign(x, /):
      return np.sign(x)
  
  def sin(x, /):
      return np.sin(x)
  
  def sinh(x, /):
      return np.sinh(x)
  
  def square(x, /):
      return np.square(x)
  
  def sqrt(x, /):
      return np.sqrt(x)
  
  def subtract(x1, x2, /):
      return np.subtract(x1, x2)
  
  def tan(x, /):
      return np.tan(x)
  
  def tanh(x, /):
      return np.tanh(x)
  
  def trunc(x, /):
      return np.trunc(x)
  
files: numpy/_array_api/_elementwise_functions.py
files: def abs(x, /):
      from .. import abs
      return abs(x)
  
  def acos(x, /):
      # Note: the function name is different here
      from .. import arccos
      return arccos(x)
  
  def acosh(x, /):
      # Note: the function name is different here
      from .. import arccosh
      return arccosh(x)
  
  def add(x1, x2, /):
      from .. import add
      return add(x1, x2)
  
  def asin(x, /):
      # Note: the function name is different here
      from .. import arcsin
      return arcsin(x)
  
  def asinh(x, /):
      # Note: the function name is different here
      from .. import arcsinh
      return arcsinh(x)
  
  def atan(x, /):
      # Note: the function name is different here
      from .. import arctan
      return arctan(x)
  
  def atan2(x1, x2, /):
      # Note: the function name is different here
      from .. import arctan2
      return arctan2(x1, x2)
  
  def atanh(x, /):
      # Note: the function name is different here
      from .. import arctanh
      return arctanh(x)
  
  def bitwise_and(x1, x2, /):
      from .. import bitwise_and
      return bitwise_and(x1, x2)
  
  def bitwise_left_shift(x1, x2, /):
      # Note: the function name is different here
      from .. import left_shift
      return left_shift(x1, x2)
  
  def bitwise_invert(x, /):
      # Note: the function name is different here
      from .. import invert
      return invert(x)
  
  def bitwise_or(x1, x2, /):
      from .. import bitwise_or
      return bitwise_or(x1, x2)
  
  def bitwise_right_shift(x1, x2, /):
      # Note: the function name is different here
      from .. import right_shift
      return right_shift(x1, x2)
  
  def bitwise_xor(x1, x2, /):
      from .. import bitwise_xor
      return bitwise_xor(x1, x2)
  
  def ceil(x, /):
      from .. import ceil
      return ceil(x)
  
  def cos(x, /):
      from .. import cos
      return cos(x)
  
  def cosh(x, /):
      from .. import cosh
      return cosh(x)
  
  def divide(x1, x2, /):
      from .. import divide
      return divide(x1, x2)
  
  def equal(x1, x2, /):
      from .. import equal
      return equal(x1, x2)
  
  def exp(x, /):
      from .. import exp
      return exp(x)
  
  def expm1(x, /):
      from .. import expm1
      return expm1(x)
  
  def floor(x, /):
      from .. import floor
      return floor(x)
  
  def floor_divide(x1, x2, /):
      from .. import floor_divide
      return floor_divide(x1, x2)
  
  def greater(x1, x2, /):
      from .. import greater
      return greater(x1, x2)
  
  def greater_equal(x1, x2, /):
      from .. import greater_equal
      return greater_equal(x1, x2)
  
  def isfinite(x, /):
      from .. import isfinite
      return isfinite(x)
  
  def isinf(x, /):
      from .. import isinf
      return isinf(x)
  
  def isnan(x, /):
      from .. import isnan
      return isnan(x)
  
  def less(x1, x2, /):
      from .. import less
      return less(x1, x2)
  
  def less_equal(x1, x2, /):
      from .. import less_equal
      return less_equal(x1, x2)
  
  def log(x, /):
      from .. import log
      return log(x)
  
  def log1p(x, /):
      from .. import log1p
      return log1p(x)
  
  def log2(x, /):
      from .. import log2
      return log2(x)
  
  def log10(x, /):
      from .. import log10
      return log10(x)
  
  def logical_and(x1, x2, /):
      from .. import logical_and
      return logical_and(x1, x2)
  
  def logical_not(x, /):
      from .. import logical_not
      return logical_not(x)
  
  def logical_or(x1, x2, /):
      from .. import logical_or
      return logical_or(x1, x2)
  
  def logical_xor(x1, x2, /):
      from .. import logical_xor
      return logical_xor(x1, x2)
  
  def multiply(x1, x2, /):
      from .. import multiply
      return multiply(x1, x2)
  
  def negative(x, /):
      from .. import negative
      return negative(x)
  
  def not_equal(x1, x2, /):
      from .. import not_equal
      return not_equal(x1, x2)
  
  def positive(x, /):
      from .. import positive
      return positive(x)
  
  def pow(x1, x2, /):
      # Note: the function name is different here
      from .. import power
      return power(x1, x2)
  
  def remainder(x1, x2, /):
      from .. import remainder
      return remainder(x1, x2)
  
  def round(x, /):
      from .. import round
      return round(x)
  
  def sign(x, /):
      from .. import sign
      return sign(x)
  
  def sin(x, /):
      from .. import sin
      return sin(x)
  
  def sinh(x, /):
      from .. import sinh
      return sinh(x)
  
  def square(x, /):
      from .. import square
      return square(x)
  
  def sqrt(x, /):
      from .. import sqrt
      return sqrt(x)
  
  def subtract(x1, x2, /):
      from .. import subtract
      return subtract(x1, x2)
  
  def tan(x, /):
      from .. import tan
      return tan(x)
  
  def tanh(x, /):
      from .. import tanh
      return tanh(x)
  
  def trunc(x, /):
      from .. import trunc
      return trunc(x)
  
files: numpy/_array_api/_elementwise_functions.py
files: import numpy as np
  
  # def cholesky():
  #     return np.cholesky()
  
  def cross(x1, x2, /, *, axis=-1):
      return np.cross(x1, x2, axis=axis)
  
  def det(x, /):
      # Note: this function is being imported from a nondefault namespace
      return np.det(x)
  
  def diagonal(x, /, *, axis1=0, axis2=1, offset=0):
      return np.diagonal(x, axis1=axis1, axis2=axis2, offset=offset)
  
  # def dot():
  #     return np.dot()
  #
  # def eig():
  #     return np.eig()
  #
  # def eigvalsh():
  #     return np.eigvalsh()
  #
  # def einsum():
  #     return np.einsum()
  
  def inv(x):
      # Note: this function is being imported from a nondefault namespace
      return np.inv(x)
  
  # def lstsq():
  #     return np.lstsq()
  #
  # def matmul():
  #     return np.matmul()
  #
  # def matrix_power():
  #     return np.matrix_power()
  #
  # def matrix_rank():
  #     return np.matrix_rank()
  
  def norm(x, /, *, axis=None, keepdims=False, ord=None):
      # Note: this function is being imported from a nondefault namespace
      # Note: this is different from the default behavior
      if axis == None and x.ndim > 2:
          x = x.flatten()
      return np.norm(x, axis=axis, keepdims=keepdims, ord=ord)
  
  def outer(x1, x2, /):
      return np.outer(x1, x2)
  
  # def pinv():
  #     return np.pinv()
  #
  # def qr():
  #     return np.qr()
  #
  # def slogdet():
  #     return np.slogdet()
  #
  # def solve():
  #     return np.solve()
  #
  # def svd():
  #     return np.svd()
  
  def trace(x, /, *, axis1=0, axis2=1, offset=0):
      return np.trace(x, axis1=axis1, axis2=axis2, offset=offset)
  
  def transpose(x, /, *, axes=None):
      return np.transpose(x, axes=axes)
  
files: numpy/_array_api/_linear_algebra_functions.py
files: # def cholesky():
  #     from .. import cholesky
  #     return cholesky()
  
  def cross(x1, x2, /, *, axis=-1):
      from .. import cross
      return cross(x1, x2, axis=axis)
  
  def det(x, /):
      # Note: this function is being imported from a nondefault namespace
      from ..linalg import det
      return det(x)
  
  def diagonal(x, /, *, axis1=0, axis2=1, offset=0):
      from .. import diagonal
      return diagonal(x, axis1=axis1, axis2=axis2, offset=offset)
  
  # def dot():
  #     from .. import dot
  #     return dot()
  #
  # def eig():
  #     from .. import eig
  #     return eig()
  #
  # def eigvalsh():
  #     from .. import eigvalsh
  #     return eigvalsh()
  #
  # def einsum():
  #     from .. import einsum
  #     return einsum()
  
  def inv(x):
      # Note: this function is being imported from a nondefault namespace
      from ..linalg import inv
      return inv(x)
  
  # def lstsq():
  #     from .. import lstsq
  #     return lstsq()
  #
  # def matmul():
  #     from .. import matmul
  #     return matmul()
  #
  # def matrix_power():
  #     from .. import matrix_power
  #     return matrix_power()
  #
  # def matrix_rank():
  #     from .. import matrix_rank
  #     return matrix_rank()
  
  def norm(x, /, *, axis=None, keepdims=False, ord=None):
      # Note: this function is being imported from a nondefault namespace
      from ..linalg import norm
      # Note: this is different from the default behavior
      if axis == None and x.ndim > 2:
          x = x.flatten()
      return norm(x, axis=axis, keepdims=keepdims, ord=ord)
  
  def outer(x1, x2, /):
      from .. import outer
      return outer(x1, x2)
  
  # def pinv():
  #     from .. import pinv
  #     return pinv()
  #
  # def qr():
  #     from .. import qr
  #     return qr()
  #
  # def slogdet():
  #     from .. import slogdet
  #     return slogdet()
  #
  # def solve():
  #     from .. import solve
  #     return solve()
  #
  # def svd():
  #     from .. import svd
  #     return svd()
  
  def trace(x, /, *, axis1=0, axis2=1, offset=0):
      from .. import trace
      return trace(x, axis1=axis1, axis2=axis2, offset=offset)
  
  def transpose(x, /, *, axes=None):
      from .. import transpose
      return transpose(x, axes=axes)
  
files: numpy/_array_api/_linear_algebra_functions.py
files: import numpy as np
  
  def concat(arrays, /, *, axis=0):
      # Note: the function name is different here
      return np.concatenate(arrays, axis=axis)
  
  def expand_dims(x, axis, /):
      return np.expand_dims(x, axis)
  
  def flip(x, /, *, axis=None):
      return np.flip(x, axis=axis)
  
  def reshape(x, shape, /):
      return np.reshape(x, shape)
  
  def roll(x, shift, /, *, axis=None):
      return np.roll(x, shift, axis=axis)
  
  def squeeze(x, /, *, axis=None):
      return np.squeeze(x, axis=axis)
  
  def stack(arrays, /, *, axis=0):
      return np.stack(arrays, axis=axis)
  
files: numpy/_array_api/_manipulation_functions.py
files: def concat(arrays, /, *, axis=0):
      # Note: the function name is different here
      from .. import concatenate
      return concatenate(arrays, axis=axis)
  
  def expand_dims(x, axis, /):
      from .. import expand_dims
      return expand_dims(x, axis)
  
  def flip(x, /, *, axis=None):
      from .. import flip
      return flip(x, axis=axis)
  
  def reshape(x, shape, /):
      from .. import reshape
      return reshape(x, shape)
  
  def roll(x, shift, /, *, axis=None):
      from .. import roll
      return roll(x, shift, axis=axis)
  
  def squeeze(x, /, *, axis=None):
      from .. import squeeze
      return squeeze(x, axis=axis)
  
  def stack(arrays, /, *, axis=0):
      from .. import stack
      return stack(arrays, axis=axis)
  
files: numpy/_array_api/_manipulation_functions.py
files: import numpy as np
  
  def argmax(x, /, *, axis=None, keepdims=False):
      return np.argmax(x, axis=axis, keepdims=keepdims)
  
  def argmin(x, /, *, axis=None, keepdims=False):
      return np.argmin(x, axis=axis, keepdims=keepdims)
  
  def nonzero(x, /):
      return np.nonzero(x)
  
  def where(condition, x1, x2, /):
      return np.where(condition, x1, x2)
  
files: numpy/_array_api/_searching_functions.py
files: def argmax(x, /, *, axis=None, keepdims=False):
      from .. import argmax
      return argmax(x, axis=axis, keepdims=keepdims)
  
  def argmin(x, /, *, axis=None, keepdims=False):
      from .. import argmin
      return argmin(x, axis=axis, keepdims=keepdims)
  
  def nonzero(x, /):
      from .. import nonzero
      return nonzero(x)
  
  def where(condition, x1, x2, /):
      from .. import where
      return where(condition, x1, x2)
  
files: numpy/_array_api/_searching_functions.py
files: import numpy as np
  
  def unique(x, /, *, return_counts=False, return_index=False, return_inverse=False, sorted=True):
      return np.unique(x, return_counts=return_counts, return_index=return_index, return_inverse=return_inverse, sorted=sorted)
  
files: numpy/_array_api/_set_functions.py
files: def unique(x, /, *, return_counts=False, return_index=False, return_inverse=False, sorted=True):
      from .. import unique
      return unique(x, return_counts=return_counts, return_index=return_index, return_inverse=return_inverse, sorted=sorted)
  
files: numpy/_array_api/_set_functions.py
files: import numpy as np
  
  def argsort(x, /, *, axis=-1, descending=False, stable=True):
      # Note: this keyword argument is different, and the default is different.
      kind = 'stable' if stable else 'quicksort'
      res = np.argsort(x, axis=axis, kind=kind)
      if descending:
          res = np.flip(res, axis=axis)
      return res
  
  def sort(x, /, *, axis=-1, descending=False, stable=True):
      # Note: this keyword argument is different, and the default is different.
      kind = 'stable' if stable else 'quicksort'
      res = np.sort(x, axis=axis, kind=kind)
      if descending:
          res = np.flip(res, axis=axis)
      return res
  
files: numpy/_array_api/_sorting_functions.py
files: def argsort(x, /, *, axis=-1, descending=False, stable=True):
      from .. import argsort
      from .. import flip
      # Note: this keyword argument is different, and the default is different.
      kind = 'stable' if stable else 'quicksort'
      res = argsort(x, axis=axis, kind=kind)
      if descending:
          res = flip(res, axis=axis)
      return res
  
  def sort(x, /, *, axis=-1, descending=False, stable=True):
      from .. import sort
      from .. import flip
      # Note: this keyword argument is different, and the default is different.
      kind = 'stable' if stable else 'quicksort'
      res = sort(x, axis=axis, kind=kind)
      if descending:
          res = flip(res, axis=axis)
      return res
  
files: numpy/_array_api/_sorting_functions.py
files: import numpy as np
  
  def max(x, /, *, axis=None, keepdims=False):
      return np.max(x, axis=axis, keepdims=keepdims)
  
  def mean(x, /, *, axis=None, keepdims=False):
      return np.mean(x, axis=axis, keepdims=keepdims)
  
  def min(x, /, *, axis=None, keepdims=False):
      return np.min(x, axis=axis, keepdims=keepdims)
  
  def prod(x, /, *, axis=None, keepdims=False):
      return np.prod(x, axis=axis, keepdims=keepdims)
  
  def std(x, /, *, axis=None, correction=0.0, keepdims=False):
      # Note: the keyword argument correction is different here
      return np.std(x, axis=axis, ddof=correction, keepdims=keepdims)
  
  def sum(x, /, *, axis=None, keepdims=False):
      return np.sum(x, axis=axis, keepdims=keepdims)
  
  def var(x, /, *, axis=None, correction=0.0, keepdims=False):
      # Note: the keyword argument correction is different here
      return np.var(x, axis=axis, ddof=correction, keepdims=keepdims)
  
files: numpy/_array_api/_statistical_functions.py
files: def max(x, /, *, axis=None, keepdims=False):
      from .. import max
      return max(x, axis=axis, keepdims=keepdims)
  
  def mean(x, /, *, axis=None, keepdims=False):
      from .. import mean
      return mean(x, axis=axis, keepdims=keepdims)
  
  def min(x, /, *, axis=None, keepdims=False):
      from .. import min
      return min(x, axis=axis, keepdims=keepdims)
  
  def prod(x, /, *, axis=None, keepdims=False):
      from .. import prod
      return prod(x, axis=axis, keepdims=keepdims)
  
  def std(x, /, *, axis=None, correction=0.0, keepdims=False):
      from .. import std
      # Note: the keyword argument correction is different here
      return std(x, axis=axis, ddof=correction, keepdims=keepdims)
  
  def sum(x, /, *, axis=None, keepdims=False):
      from .. import sum
      return sum(x, axis=axis, keepdims=keepdims)
  
  def var(x, /, *, axis=None, correction=0.0, keepdims=False):
      from .. import var
      # Note: the keyword argument correction is different here
      return var(x, axis=axis, ddof=correction, keepdims=keepdims)
  
files: numpy/_array_api/_statistical_functions.py
files: import numpy as np
  
  def all(x, /, *, axis=None, keepdims=False):
      return np.all(x, axis=axis, keepdims=keepdims)
  
  def any(x, /, *, axis=None, keepdims=False):
      return np.any(x, axis=axis, keepdims=keepdims)
  
files: numpy/_array_api/_utility_functions.py
files: def all(x, /, *, axis=None, keepdims=False):
      from .. import all
      return all(x, axis=axis, keepdims=keepdims)
  
  def any(x, /, *, axis=None, keepdims=False):
      from .. import any
      return any(x, axis=axis, keepdims=keepdims)
  
files: numpy/_array_api/_utility_functions.py