adam.core.array_api_math
========================

.. py:module:: adam.core.array_api_math


Classes
-------

.. autoapisummary::

   adam.core.array_api_math.ArraySpec
   adam.core.array_api_math.ArrayAPILike
   adam.core.array_api_math.ArrayAPIFactory
   adam.core.array_api_math.ArrayAPISpatialMath


Functions
---------

.. autoapisummary::

   adam.core.array_api_math.spec_from_reference
   adam.core.array_api_math.xp_getter


Module Contents
---------------

.. py:class:: ArraySpec

   .. py:attribute:: xp
      :type:  types.ModuleType


   .. py:attribute:: dtype
      :type:  Optional[Any]


   .. py:attribute:: device
      :type:  Optional[Any]


.. py:function:: spec_from_reference(ref: Any) -> ArraySpec

.. py:function:: xp_getter(*xs: Any)

.. py:class:: ArrayAPILike

   Bases: :py:obj:`adam.core.spatial_math.ArrayLike`


   Generic Array-API-style wrapper used by NumPy/JAX/Torch backends.


   .. py:attribute:: array
      :type:  Any


   .. py:method:: __getitem__(idx) -> ArrayAPILike


   .. py:property:: shape


   .. py:method:: reshape(*args)


   .. py:property:: T
      :type: ArrayAPILike


      Transpose of the array

      :type: Returns


   .. py:method:: __matmul__(other)


   .. py:method:: __rmatmul__(other) -> ArrayAPILike


   .. py:method:: __mul__(other) -> ArrayAPILike


   .. py:method:: __rmul__(other) -> ArrayAPILike


   .. py:method:: __truediv__(other) -> ArrayAPILike


   .. py:method:: __add__(other) -> ArrayAPILike


   .. py:method:: __radd__(other) -> ArrayAPILike


   .. py:method:: __sub__(other) -> ArrayAPILike


   .. py:method:: __rsub__(other) -> ArrayAPILike


   .. py:method:: __neg__() -> ArrayAPILike


   .. py:property:: ndim


.. py:class:: ArrayAPIFactory(like_cls, xp, *, dtype=None, device=None)

   Bases: :py:obj:`adam.core.spatial_math.ArrayLikeFactory`


   Generic factory. Give it (a) a Like class and (b) an xp namespace
   (array_api_compat.* if available; otherwise the library module).


   .. py:attribute:: _like


   .. py:attribute:: _xp


   .. py:attribute:: _dtype
      :value: None



   .. py:attribute:: _device
      :value: None



   .. py:method:: zeros(*shape) -> ArrayAPILike

      :param x: matrix dimension
      :type x: npt.ArrayLike

      :returns: zero matrix of dimension x
      :rtype: npt.ArrayLike



   .. py:method:: eye(*shape) -> ArrayAPILike

      :param x: matrix dimension
      :type x: npt.ArrayLike

      :returns: identity matrix of dimension x
      :rtype: npt.ArrayLike



   .. py:method:: asarray(x) -> ArrayAPILike

      :param x: array
      :type x: npt.ArrayLike

      :returns: array
      :rtype: npt.ArrayLike



   .. py:method:: zeros_like(x: ArrayAPILike) -> ArrayAPILike

      :param x: array
      :type x: npt.ArrayLike

      :returns: one array with the same shape as x
      :rtype: npt.ArrayLike



   .. py:method:: ones_like(x: ArrayAPILike) -> ArrayAPILike

      :param x: array
      :type x: npt.ArrayLike

      :returns: one array with the same shape as x
      :rtype: npt.ArrayLike



   .. py:method:: tile(x: ArrayAPILike, reps: tuple) -> ArrayAPILike

      :param x: input array
      :type x: npt.ArrayLike
      :param reps: repetition factors for each dimension
      :type reps: tuple

      :returns: tiled array
      :rtype: npt.ArrayLike



.. py:class:: ArrayAPISpatialMath(factory, xp_getter: Callable[Ellipsis, Any] = xp_getter)

   Bases: :py:obj:`adam.core.spatial_math.SpatialMath`


   A drop-in SpatialMath that implements sin/cos/outer/concat/skew with the Array API.

   Works for NumPy, PyTorch, and JAX; CasADi should keep its own subclass.


   .. py:attribute:: _xp_getter


   .. py:method:: _xp(*xs: Any)


   .. py:method:: sin(x)

      :param x: angle value
      :type x: npt.ArrayLike

      :returns: sin value of x
      :rtype: npt.ArrayLike



   .. py:method:: cos(x)

      :param x: angle value
      :type x: npt.ArrayLike

      :returns: cos value of angle x
      :rtype: npt.ArrayLike



   .. py:method:: skew(x)


   .. py:method:: outer(x, y)


   .. py:method:: vertcat(*x)

      :param x: elements
      :type x: npt.ArrayLike

      :returns: vertical concatenation of elements x
      :rtype: npt.ArrayLike



   .. py:method:: horzcat(*x)

      :param x: elements
      :type x: npt.ArrayLike

      :returns: horizontal concatenation of elements x
      :rtype: npt.ArrayLike



   .. py:method:: stack(x, axis=0)

      :param x: elements
      :type x: npt.ArrayLike
      :param axis: axis along which to stack
      :type axis: int

      :returns: stacked elements x along axis
      :rtype: npt.ArrayLike



   .. py:method:: concatenate(x, axis=0)

      :param x: elements
      :type x: npt.ArrayLike
      :param axis: axis along which to concatenate
      :type axis: int

      :returns: concatenation of elements x along axis
      :rtype: npt.ArrayLike



   .. py:method:: swapaxes(x: ArrayAPILike, axis1: int, axis2: int) -> ArrayAPILike


   .. py:method:: expand_dims(x: ArrayAPILike, axis: int) -> ArrayAPILike


   .. py:method:: transpose(x: ArrayAPILike, dims: tuple) -> ArrayAPILike

      :param x: input array
      :type x: npt.ArrayLike
      :param dims: permutation of dimensions
      :type dims: tuple

      :returns: transposed array
      :rtype: npt.ArrayLike



   .. py:method:: inv(x: ArrayAPILike) -> ArrayAPILike

      :param x: input array
      :type x: npt.ArrayLike

      :returns: inverse of the array
      :rtype: npt.ArrayLike



   .. py:method:: mtimes(A: ArrayAPILike, B: ArrayAPILike) -> ArrayAPILike


   .. py:method:: solve(A: ArrayAPILike, B: ArrayAPILike) -> ArrayAPILike