cobra-array 0.2.0__tar.gz → 0.2.2__tar.gz

{cobra_array-0.2.0/src/cobra_array.egg-info → cobra_array-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cobra-array
-Version: 0.2.0
+Version: 0.2.2
 Summary: A backend-agnostic array utility library that unifies array conversion, context control, and cross-library operations across `NumPy`/`PyTorch`-style ecosystems.
 Author-email: Zhen Tian <zhen.tian.cs@gmail.com>
 Project-URL: Homepage, https://github.com/tinchen777/cobra-array.git

{cobra_array-0.2.0 → cobra_array-0.2.2}/src/cobra_array/__init__.py

@@ -80,7 +80,7 @@ from ._utils import (
 )
 
 __author__ = "Zhen Tian"
-__version__ = "0.2.0"
+__version__ = "0.2.2"
 
 __all__ = [
     "array_spec",

{cobra_array-0.2.0 → cobra_array-0.2.2}/src/cobra_array/compat/_array.py

@@ -339,7 +339,7 @@ class CompatArray(Compat):
     @property
     def device(self):
         """
-        DeviceT on which `self` is stored.
+        Device on which `self` is stored.
         """
         return api.device(self._arr)
 
@@ -402,7 +402,7 @@ class CompatArray(Compat):
         """Allow implicit NumPy conversion."""
         return self.to_numpy()
 
-    def __getattr__(self, name: str):
+    def __getattr__(self, name):
         attr = self._get_xp_attr(name)
 
         if callable(attr) and not isinstance(attr, type):

{cobra_array-0.2.0 → cobra_array-0.2.2}/src/cobra_array/compat/_array.pyi

@@ -10,7 +10,7 @@ from typing import (Union, List, Tuple, Optional, Any, Sequence, Generic, TypeVa
 from ._base import Compat
 from ._namespace import CompatNamespace
 from ..types import (
-    T, DTypeT, DeviceT, dtypeT, deviceT, DType, AnyDevice,
+    T, dtypeT, DTypeT, deviceT, DeviceT, DType, AnyDevice,
     ArrayLike, ArrayLibraryName,
     ArrayOrAny, ArrayOrScalar, ArrayOrReal, ArrayOrIntLike, ArrayOrInt, ArrayOrbool,
     UniqueAllResult, UniqueCountsResult, UniqueInverseResult
@@ -64,7 +64,6 @@ class CompatArray(Compat, Generic[TT, DT]):
     def to_device(self, device: DeviceT, /, *, stream: Optional[Any] = None) -> CompatArray[TT, DeviceT]: ...
     @overload
     def to_device(self, device: AnyDevice, /, *, stream: Optional[Any] = None) -> CompatArray[TT, AnyDevice]: ...
-
     def to_device(self, device: AnyDevice, /, *, stream: Optional[Any] = None) -> CompatArray[Any, AnyDevice]: ...
 
     # === Data type functions ===
@@ -117,14 +116,14 @@ class CompatArray(Compat, Generic[TT, DT]):
         """
         ...
 
-    def acos(self) -> CompatArray[float, DT]:
+    def acos(self) -> CompatArray[type[float], DT]:
         """
         Computes the element-wise `principal value of the inverse cosine` of `self`.
         - `self` should have a floating-point data type.
         """
         ...
 
-    def acosh(self) -> CompatArray[float, DT]:
+    def acosh(self) -> CompatArray[type[float], DT]:
         """
         Computes the element-wise `inverse hyperbolic cosine` of `self`.
         - `self` should have a floating-point data type.
@@ -138,28 +137,28 @@ class CompatArray(Compat, Generic[TT, DT]):
         """
         ...
 
-    def asin(self) -> CompatArray[float, DT]:
+    def asin(self) -> CompatArray[type[float], DT]:
         """
         Computes the element-wise `principal value of the inverse sine` of `self`.
         - `self` should have a floating-point data type.
         """
         ...
 
-    def asinh(self) -> CompatArray[float, DT]:
+    def asinh(self) -> CompatArray[type[float], DT]:
         """
         Computes the element-wise `inverse hyperbolic sine` of `self`.
         - `self` should have a floating-point data type.
         """
         ...
 
-    def atan(self) -> CompatArray[float, DT]:
+    def atan(self) -> CompatArray[type[float], DT]:
         """
         Computes the element-wise `principal value of the inverse tangent` of `self`.
         - `self` should have a floating-point data type.
         """
         ...
 
-    def atan2(self, other: ArrayOrReal, /) -> CompatArray[float, DT]:
+    def atan2(self, other: ArrayOrReal, /) -> CompatArray[type[float], DT]:
         """
         Computes the element-wise `inverse tangent` of `self / other`, taking into account the signs of both inputs.
         - `self` should have a real-valued floating-point data type.
@@ -167,7 +166,7 @@ class CompatArray(Compat, Generic[TT, DT]):
         """
         ...
 
-    def atanh(self) -> CompatArray[float, DT]:
+    def atanh(self) -> CompatArray[type[float], DT]:
         """
         Computes the element-wise `inverse hyperbolic tangent` of `self`.
         - `self` should have a floating-point data type.
@@ -241,7 +240,7 @@ class CompatArray(Compat, Generic[TT, DT]):
         """
         ...
 
-    def copysign(self, other: ArrayOrReal, /) -> CompatArray[float, DT]:
+    def copysign(self, other: ArrayOrReal, /) -> CompatArray[type[float], DT]:
         """
         Computes the element-wise `copysign` of `self` with `other`.
         - `self` should have a real-valued floating-point data type.
@@ -249,41 +248,41 @@ class CompatArray(Compat, Generic[TT, DT]):
         """
         ...
 
-    def cos(self) -> CompatArray[float, DT]:
+    def cos(self) -> CompatArray[type[float], DT]:
         """
         Computes the element-wise `cosine` of `self`.
         - `self` should have a floating-point data type.
         """
         ...
 
-    def cosh(self) -> CompatArray[float, DT]:
+    def cosh(self) -> CompatArray[type[float], DT]:
         """
         Computes the element-wise `hyperbolic cosine` of `self`.
         - `self` should have a floating-point data type.
         """
         ...
 
-    def divide(self, other: ArrayOrScalar, /) -> CompatArray[float, DT]:
+    def divide(self, other: ArrayOrScalar, /) -> CompatArray[type[float], DT]:
         """
         Computes the element-wise `division` of `self` by `other`.
         - `self` should have a numeric data type.
         """
         ...
 
-    def equal(self, other: ArrayOrAny, /) -> CompatArray[bool, DT]:
+    def equal(self, other: ArrayOrAny, /) -> CompatArray[type[bool], DT]:
         """
         Computes the element-wise truth value of `self == other`.
         """
         ...
 
-    def exp(self) -> CompatArray[float, DT]:
+    def exp(self) -> CompatArray[type[float], DT]:
         """
         Computes the element-wise `exponential` (`exp(x)`) of `self`.
         - `self` should have a floating-point data type.
         """
         ...
 
-    def expm1(self) -> CompatArray[float, DT]:
+    def expm1(self) -> CompatArray[type[float], DT]:
         """
         Computes the element-wise `exp(x) - 1` of `self`.
         - `self` should have a floating-point data type.
@@ -306,21 +305,21 @@ class CompatArray(Compat, Generic[TT, DT]):
         """
         ...
 
-    def greater(self, other: ArrayOrReal, /) -> CompatArray[bool, DT]:
+    def greater(self, other: ArrayOrReal, /) -> CompatArray[type[bool], DT]:
         """
         Computes the element-wise truth value of `self > other`.
         - `self` should have a real-valued data type.
         """
         ...
 
-    def greater_equal(self, other: ArrayOrReal, /) -> CompatArray[bool, DT]:
+    def greater_equal(self, other: ArrayOrReal, /) -> CompatArray[type[bool], DT]:
         """
         Computes the element-wise truth value of `self >= other`.
         - `self` should have a real-valued data type.
         """
         ...
 
-    def hypot(self, other: ArrayOrReal, /) -> CompatArray[float, DT]:
+    def hypot(self, other: ArrayOrReal, /) -> CompatArray[type[float], DT]:
         """
         Computes the element-wise `hypotenuse` of `self` and `other`.
         - `self` should have a real-valued floating-point data type.
@@ -328,77 +327,77 @@ class CompatArray(Compat, Generic[TT, DT]):
         """
         ...
 
-    def imag(self) -> CompatArray[float, DT]:
+    def imag(self) -> CompatArray[type[float], DT]:
         """
         Computes the element-wise `imaginary component` of `self`.
         - `self` should have a complex floating-point data type.
         """
         ...
 
-    def isfinite(self) -> CompatArray[bool, DT]:
+    def isfinite(self) -> CompatArray[type[bool], DT]:
         """
         Tests the element-wise `finiteness` of `self`.
         - `self` should have a numeric data type.
         """
         ...
 
-    def isinf(self) -> CompatArray[bool, DT]:
+    def isinf(self) -> CompatArray[type[bool], DT]:
         """
         Tests the element-wise `infinity` of `self`.
         - - `self` should have a numeric data type.
         """
         ...
 
-    def isnan(self) -> CompatArray[bool, DT]:
+    def isnan(self) -> CompatArray[type[bool], DT]:
         """
         Tests the element-wise `NaN` of `self`.
         - `self` should have a numeric data type.
         """
         ...
 
-    def less(self, other: ArrayOrReal, /) -> CompatArray[bool, DT]:
+    def less(self, other: ArrayOrReal, /) -> CompatArray[type[bool], DT]:
         """
         Computes the element-wise truth value of `self < other`.
         - `self` should have a real-valued data type.
         """
         ...
 
-    def less_equal(self, other: ArrayOrReal, /) -> CompatArray[bool, DT]:
+    def less_equal(self, other: ArrayOrReal, /) -> CompatArray[type[bool], DT]:
         """
         Computes the element-wise truth value of `self <= other`.
         - `self` should have a real-valued data type.
         """
         ...
 
-    def log(self) -> CompatArray[float, DT]:
+    def log(self) -> CompatArray[type[float], DT]:
         """
         Computes the element-wise `natural logarithm` (base `e`)  of `self`.
         - `self` should have a floating-point data type.
         """
         ...
 
-    def log1p(self) -> CompatArray[float, DT]:
+    def log1p(self) -> CompatArray[type[float], DT]:
         """
         Computes the element-wise `log(1 + x)` (base `e`) of `self`.
         - `self` should have a floating-point data type.
         """
         ...
 
-    def log2(self) -> CompatArray[float, DT]:
+    def log2(self) -> CompatArray[type[float], DT]:
         """
         Computes the element-wise `base-2 logarithm` of `self`.
         - `self` should have a floating-point data type.
         """
         ...
 
-    def log10(self) -> CompatArray[float, DT]:
+    def log10(self) -> CompatArray[type[float], DT]:
         """
         Computes the element-wise `base-10 logarithm` of `self`.
         - `self` should have a floating-point data type.
         """
         ...
 
-    def logaddexp(self, other: ArrayOrReal, /) -> CompatArray[float, DT]:
+    def logaddexp(self, other: ArrayOrReal, /) -> CompatArray[type[float], DT]:
         """
         Computes the element-wise `logaddexp` of `self` and `other`.
         - Equivalent to `log(exp(self) + exp(other))`.
@@ -406,28 +405,28 @@ class CompatArray(Compat, Generic[TT, DT]):
         """
         ...
 
-    def logical_and(self, other: ArrayOrbool, /) -> CompatArray[bool, DT]:
+    def logical_and(self, other: ArrayOrbool, /) -> CompatArray[type[bool], DT]:
         """
         Computes the element-wise `logical AND` of `self` and `other`.
         - `self` should have a boolean data type.
         """
         ...
 
-    def logical_not(self) -> CompatArray[bool, DT]:
+    def logical_not(self) -> CompatArray[type[bool], DT]:
         """
         Computes the element-wise `logical NOT` of `self`.
         - `self` should have a boolean data type.
         """
         ...
 
-    def logical_or(self, other: ArrayOrbool, /) -> CompatArray[bool, DT]:
+    def logical_or(self, other: ArrayOrbool, /) -> CompatArray[type[bool], DT]:
         """
         Computes the element-wise `logical OR` of `self` and `other`.
         - `self` should have a boolean data type.
         """
         ...
 
-    def logical_xor(self, other: ArrayOrbool, /) -> CompatArray[bool, DT]:
+    def logical_xor(self, other: ArrayOrbool, /) -> CompatArray[type[bool], DT]:
         """
         Computes the element-wise `logical XOR` of `self` and `other`.
         - `self` should have a boolean data type.
@@ -469,7 +468,7 @@ class CompatArray(Compat, Generic[TT, DT]):
         """
         ...
 
-    def not_equal(self, other: ArrayOrAny, /) -> CompatArray[bool, DT]:
+    def not_equal(self, other: ArrayOrAny, /) -> CompatArray[type[bool], DT]:
         """
         Computes the element-wise truth value of `self != other`.
         """
@@ -490,14 +489,14 @@ class CompatArray(Compat, Generic[TT, DT]):
         """
         ...
 
-    def real(self) -> CompatArray[float, DT]:
+    def real(self) -> CompatArray[type[float], DT]:
         """
         Computes the element-wise `real component` of `self`.
         - `self` should have a numeric data type.
         """
         ...
 
-    def reciprocal(self) -> CompatArray[float, DT]:
+    def reciprocal(self) -> CompatArray[type[float], DT]:
         """
         Computes the element-wise `reciprocal` of `self`.
         - `self` should have a floating-point data type.
@@ -525,7 +524,7 @@ class CompatArray(Compat, Generic[TT, DT]):
         """
         ...
 
-    def signbit(self) -> CompatArray[bool, DT]:
+    def signbit(self) -> CompatArray[type[bool], DT]:
         """
         Tests the element-wise `sign bit` of `self`.
         - Tests each element for whenever is either `-0`, `less than zero`, or a signed `NaN` (i.e., a NaN value whose sign bit is 1).
@@ -533,14 +532,14 @@ class CompatArray(Compat, Generic[TT, DT]):
         """
         ...
 
-    def sin(self) -> CompatArray[float, DT]:
+    def sin(self) -> CompatArray[type[float], DT]:
         """
         Computes the element-wise `sine` of `self`.
         - `self` should have a floating-point data type.
         """
         ...
 
-    def sinh(self) -> CompatArray[float, DT]:
+    def sinh(self) -> CompatArray[type[float], DT]:
         """
         Computes the element-wise `hyperbolic sine` of `self`.
         - `self` should have a floating-point data type.
@@ -554,7 +553,7 @@ class CompatArray(Compat, Generic[TT, DT]):
         """
         ...
 
-    def sqrt(self) -> CompatArray[float, DT]:
+    def sqrt(self) -> CompatArray[type[float], DT]:
         """
         Computes the element-wise `principal square root` of `self`.
         - `self` should have a floating-point data type.
@@ -568,14 +567,14 @@ class CompatArray(Compat, Generic[TT, DT]):
         """
         ...
 
-    def tan(self) -> CompatArray[float, DT]:
+    def tan(self) -> CompatArray[type[float], DT]:
         """
         Computes the element-wise `tangent` of `self`.
         - `self` should have a floating-point data type.
         """
         ...
 
-    def tanh(self) -> CompatArray[float, DT]:
+    def tanh(self) -> CompatArray[type[float], DT]:
         """
         Computes the element-wise `hyperbolic tangent` of `self`.
         - `self` should have a floating-point data type.
@@ -994,7 +993,7 @@ class CompatArray(Compat, Generic[TT, DT]):
         self, *,
         axis: Optional[int] = None,
         keepdims: bool = False
-    ) -> CompatArray[int, DT]:
+    ) -> CompatArray[type[int], DT]:
         """
         Returns the indices of the maximum values along a specified axis.
 
@@ -1027,7 +1026,7 @@ class CompatArray(Compat, Generic[TT, DT]):
         self, *,
         axis: Optional[int] = None,
         keepdims: bool = False
-    ) -> CompatArray[int, DT]:
+    ) -> CompatArray[type[int], DT]:
         """
         Returns the indices of the minimum values along a specified axis.
 
@@ -1056,13 +1055,13 @@ class CompatArray(Compat, Generic[TT, DT]):
         """
         ...
 
-    def nonzero(self) -> Tuple[CompatArray[int, DT], ...]: ...
+    def nonzero(self) -> Tuple[CompatArray[type[int], DT], ...]: ...
 
     def count_nonzero(
         self, *,
         axis: Optional[Union[int, Tuple[int, ...]]] = None,
         keepdims: bool = False
-    ) -> CompatArray[int, DT]:
+    ) -> CompatArray[type[int], DT]:
         """
         Counts the number of `self` elements which are non-zero.
 
@@ -1097,7 +1096,7 @@ class CompatArray(Compat, Generic[TT, DT]):
         /, *,
         side: Literal['left', 'right'] = "left",
         sorter: Optional[ArrayLike[Any]] = None
-    ) -> CompatArray[int, DT]:
+    ) -> CompatArray[type[int], DT]:
         """
         Finds the indices into `self` such that, if the corresponding elements in `other` were inserted before the indices, the order of `self`, when sorted in ascending order, would be preserved.
         - `self` must be a one-dimensional array. Should have a real-valued data type.
@@ -1188,7 +1187,7 @@ class CompatArray(Compat, Generic[TT, DT]):
         axis: int = -1,
         descending: bool = False,
         stable: bool = True
-    ) -> CompatArray[int, DT]:
+    ) -> CompatArray[type[int], DT]:
         """
         Returns the indices that sort `self` along a specified axis.
 
@@ -1634,7 +1633,7 @@ class CompatArray(Compat, Generic[TT, DT]):
         self, *,
         axis: Optional[Union[int, Tuple[int, ...]]] = None,
         keepdims: bool = False
-    ) -> CompatArray[bool, DT]:
+    ) -> CompatArray[type[bool], DT]:
         """
         Tests whether all `self` elements evaluate to `True` along a specified axis.
         - `Positive infinity`, `negative infinity`, and `NaN` must evaluate to `True`;
@@ -1667,7 +1666,7 @@ class CompatArray(Compat, Generic[TT, DT]):
         self, *,
         axis: Optional[Union[int, Tuple[int, ...]]] = None,
         keepdims: bool = False
-    ) -> CompatArray[bool, DT]:
+    ) -> CompatArray[type[bool], DT]:
         """
         Tests whether any `self` elements evaluate to `True` along a specified axis.
         - `Positive infinity`, `negative infinity`, and `NaN` must evaluate to `True`;
@@ -1771,28 +1770,30 @@ class CompatArray(Compat, Generic[TT, DT]):
 
     def __array__(self) -> NDArray[TT]: ...
 
+    def __getattr__(self, name: str) -> Any: ...
+
     def __len__(self) -> int: ...
     def __abs__(self) -> CompatArray[TT, DT]: ...
     def __add__(self, other: ArrayOrScalar, /) -> CompatArray[Any, DT]: ...
     def __and__(self, other: ArrayOrIntLike, /) -> CompatArray[TT, DT]: ...
     def __bool__(self) -> bool: ...
     def __complex__(self) -> complex: ...
-    def __eq__(self, other: ArrayOrAny, /) -> CompatArray[bool, DT]: ...
+    def __eq__(self, other: ArrayOrAny, /) -> CompatArray[type[bool], DT]: ...
     def __float__(self) -> float: ...
     def __floordiv__(self, other: ArrayOrReal, /) -> CompatArray[TT, DT]: ...
-    def __ge__(self, other: ArrayOrReal, /) -> CompatArray[bool, DT]: ...
+    def __ge__(self, other: ArrayOrReal, /) -> CompatArray[type[bool], DT]: ...
     def __getitem__(self, key: Any, /) -> CompatArray[TT, DT]: ...
-    def __gt__(self, other: ArrayOrReal, /) -> CompatArray[bool, DT]: ...
+    def __gt__(self, other: ArrayOrReal, /) -> CompatArray[type[bool], DT]: ...
     def __index__(self) -> int: ...
     def __int__(self) -> int: ...
     def __invert__(self) -> CompatArray[TT, DT]: ...
-    def __le__(self, other: ArrayOrReal, /) -> CompatArray[bool, DT]: ...
+    def __le__(self, other: ArrayOrReal, /) -> CompatArray[type[bool], DT]: ...
     def __lshift__(self, other: ArrayOrInt, /) -> CompatArray[TT, DT]: ...
-    def __lt__(self, other: ArrayOrReal, /) -> CompatArray[bool, DT]: ...
+    def __lt__(self, other: ArrayOrReal, /) -> CompatArray[type[bool], DT]: ...
     def __matmul__(self, other: ArrayLike[Any], /) -> CompatArray[Any, DT]: ...
     def __mod__(self, other: ArrayOrReal, /) -> CompatArray[Any, DT]: ...
     def __mul__(self, other: ArrayOrScalar, /) -> CompatArray[Any, DT]: ...
-    def __ne__(self, other: ArrayOrAny, /) -> CompatArray[bool, DT]: ...
+    def __ne__(self, other: ArrayOrAny, /) -> CompatArray[type[bool], DT]: ...
     def __neg__(self) -> CompatArray[TT, DT]: ...
     def __or__(self, other: ArrayOrIntLike, /) -> CompatArray[TT, DT]: ...
     def __pos__(self) -> CompatArray[TT, DT]: ...
@@ -1800,7 +1801,7 @@ class CompatArray(Compat, Generic[TT, DT]):
     def __rshift__(self, other: ArrayOrInt, /) -> CompatArray[TT, DT]: ...
     def __setitem__(self, key: Any, value: Any, /): ...
     def __sub__(self, other: ArrayOrScalar, /) -> CompatArray[Any, DT]: ...
-    def __truediv__(self, other: ArrayOrScalar, /) -> CompatArray[float, DT]: ...
+    def __truediv__(self, other: ArrayOrScalar, /) -> CompatArray[type[float], DT]: ...
     def __xor__(self, other: ArrayOrIntLike, /) -> CompatArray[TT, DT]: ...
 
 

{cobra_array-0.2.0 → cobra_array-0.2.2}/src/cobra_array/compat/_namespace.py

@@ -236,6 +236,137 @@ class CompatNamespace(Compat):
         result = self._get_xp_attr("broadcast_arrays")(*[unwrap(arr) for arr in arrays])
         return [CompatArray(arr, xp=self) for arr in result]
 
+    # === Linear Algebra Extension ===
+    def vector_norm(self, x, /, *, axis=None, keepdims=False, ord=2):
+        """
+        Computes the vector norm of a vector (or batch of vectors) :param:`x`.
+
+        Parameters
+        ----------
+            x : ArrayLike[Any]
+                The input array. Should have a floating-point data type.
+
+            axis : Optional[Union[int, Tuple[int, ...]]], default to `None`
+                - _int_: :param:`axis` specifies the axis (dimension) along which to compute vector norms;
+                - _tuple_: :param:`axis` specifies the axes (dimensions) along which to compute batched vector norms;
+                - `None`: The vector norm must be computed over all array values (i.e., equivalent to computing the vector norm of a flattened array).
+
+                Negative indices must be supported.
+
+            keepdims : bool, default to `False`
+                - `True`: The axes (dimensions) specified by :param:`axis` must be included in the result as singleton dimensions, and, accordingly, the result must be compatible with the input array (see Broadcasting);
+                - `False`: The axes (dimensions) specified by :param:`axis` must not be included in the result.
+
+            ord : Union[int, float, Literal['inf', '-inf']], default to `2`
+                Order of the norm.
+                The following mathematical norms must be supported:
+                - `1`: L1-norm (Manhattan);
+                - `2`: L2-norm (Euclidean);
+                - `"inf"`: infinity norm;
+                - _int_ or _float_ (>=1): p-norm.
+
+                The following non-mathematical “norms” must be supported:
+                - `0`: sum(a != 0);
+                - `-1`: 1./sum(1./abs(a));
+                - `-2`: 1./sqrt(sum(1./a**2));
+                - `"-inf"`: min(abs(a));
+                - _int_ or _float_ (<1): sum(abs(a)**ord)**(1./ord).
+
+        Returns
+        -------
+            CompatArray
+                A :class:`CompatArray` array containing the vector norms.
+                - :param:`axis` is `None`: The returned array must be a zero-dimensional array containing a vector norm;
+                - :param:`axis` is a scalar value (_int_ or _float_): The returned array must have a rank which is one less than the rank of :param:`x`;
+                - :param:`axis` is _tuple_ (`n` elements): The returned array must have a rank which is `n` less than the rank of :param:`x`;
+
+                - :param:`x` is real-valued data type: The returned array must have a real-valued floating-point data type determined by Type Promotion Rules;
+                - :param:`x` is complex-valued data type: The returned array must have a real-valued floating-point data type whose precision matches the precision of :param:`x` (e.g., if :param:`x` is complex128, then the returned array must have a float64 data type).
+        """
+        if ord == "inf":
+            ord = float("inf")
+        elif ord == "-inf":
+            ord = float("-inf")
+
+        result = getattr(self.linalg, "vector_norm")(unwrap(x), axis=axis, keepdims=keepdims, ord=ord)
+        return CompatArray(result, xp=self)
+
+    def matrix_norm(self, x, /, *, keepdims=False, ord="fro"):
+        """
+        Computes the matrix norm of a matrix (or a stack of matrices) :param:`x`.
+
+        Parameters
+        ----------
+            x : ArrayLike[Any]
+                Input array having shape (..., `M`, `N`) and whose innermost two dimensions form `MxN` matrices. Should have a floating-point data type.
+
+            keepdims : bool, default to `False`
+                - `True`: The last two axes (dimensions) must be included in the result as singleton dimensions, and, accordingly, the result must be compatible with the input array (see Broadcasting);
+                - `False`: The last two axes (dimensions) must not be included in the result.
+
+            ord : Optional[Union[int, float, Literal['inf', '-inf', 'fro', 'nuc']]], default to `"fro"`
+                order of the norm.
+                The following mathematical norms must be supported:
+                - `"fro"`: Frobenius norm;
+                - `"nuc"`: nuclear norm;
+                - `1`: max(sum(abs(x), axis=0)). The norm corresponds to the induced matrix norm where `p=1` (i.e., the maximum absolute value column sum);
+                - `2`: largest singular value. The norm corresponds to the induced matrix norm where `p=inf` (i.e., the maximum absolute value row sum);
+                - `"inf"`: max(sum(abs(x), axis=1)). The norm corresponds to the induced matrix norm where `p=2` (i.e., the largest singular value).
+
+                The following non-mathematical “norms” must be supported:
+                - `-1`: min(sum(abs(x), axis=0));
+                - `-2`: smallest singular value;
+                - `"-inf"`: min(sum(abs(x), axis=1)).
+
+        Returns
+        -------
+            CompatArray
+                A :class:`CompatArray` array containing the norms for each `MxN` matrix.
+                - :param:`keepdims` is `False`: The returned array must have a rank which is two less than the rank of :param:`x`;
+
+                - :param:`x` is real-valued data type: The returned array must have a real-valued floating-point data type determined by Type Promotion Rules;
+                - :param:`x` is complex-valued data type: The returned array must have a real-valued floating-point data type whose precision matches the precision of :param:`x` (e.g., if :param:`x` is complex128, then the returned array must have a float64 data type).
+
+        """
+        if ord == "inf":
+            ord = float("inf")
+        elif ord == "-inf":
+            ord = float("-inf")
+
+        result = getattr(self.linalg, "matrix_norm")(unwrap(x), keepdims=keepdims, ord=ord)
+        return CompatArray(result, xp=self)
+
+    @property
+    def linalg(self):
+        """
+        The `linalg` namespace for linear algebra functions.
+        The following functions must be supported in the `linalg` namespace:
+        - `cholesky`(x, /, *, upper=False): Returns the lower (upper) Cholesky decomposition of a complex Hermitian or real symmetric positive-definite matrix x.
+        - `cross`(x1, x2, /, *, axis=-1): Returns the cross product of 3-element vectors.
+        - `det`(x, /): Returns the determinant of a square matrix (or a stack of square matrices) x.
+        - `diagonal`(x, /, *, offset=0): Returns the specified diagonals of a matrix (or a stack of matrices) x.
+        - `eigh`(x, /): Returns an eigenvalue decomposition of a complex Hermitian or real symmetric matrix (or a stack of matrices) x.
+        - `eigvalsh`(x, /): Returns the eigenvalues of a complex Hermitian or real symmetric matrix (or a stack of matrices) x.
+        - `inv`(x, /): Returns the multiplicative inverse of a square matrix (or a stack of square matrices) x.
+        - `matmul`(x1, x2, /): Alias for matmul().
+        - `matrix_norm`(x, /, *, keepdims=False, ord='fro'): Computes the matrix norm of a matrix (or a stack of matrices) x.
+        - `matrix_power`(x, n, /): Raises a square matrix (or a stack of square matrices) x to an integer power n.
+        - `matrix_rank`(x, /, *, rtol=None): Returns the rank (i.e., number of non-zero singular values) of a matrix (or a stack of matrices).
+        - `matrix_transpose`(x, /): Alias for matrix_transpose().
+        - `outer`(x1, x2, /): Returns the outer product of two vectors x1 and x2.
+        - `pinv`(x, /, *, rtol=None): Returns the (Moore-Penrose) pseudo-inverse of a matrix (or a stack of matrices) x.
+        - `qr`(x, /, *, mode='reduced'): Returns the QR decomposition of a full column rank matrix (or a stack of matrices).
+        - `slogdet`(x, /): Returns the sign and the natural logarithm of the absolute value of the determinant of a square matrix (or a stack of square matrices) x.
+        - `solve`(x1, x2, /): Returns the solution of a square system of linear equations with a unique solution.
+        - `svd`(x, /, *, full_matrices=True): Returns a singular value decomposition (SVD) of a matrix (or a stack of matrices) x.
+        - `svdvals`(x, /): Returns the singular values of a matrix (or a stack of matrices) x.
+        - `tensordot`(x1, x2, /, *, axes=2): Alias for tensordot().
+        - `trace`(x, /, *, offset=0, dtype=None): Returns the sum along the specified diagonals of a matrix (or a stack of matrices) x.
+        - `vecdot`(x1, x2, /, *, axis=-1): Alias for vecdot().
+        - `vector_norm`(x, /, *, axis=None, keepdims=False, ord=2): Computes the vector norm of a vector (or batch of vectors) x.
+        """
+        return self._get_xp_attr("linalg")
+
     # === Constants ===
     @property
     def e(self):

{cobra_array-0.2.0 → cobra_array-0.2.2}/src/cobra_array/compat/_namespace.pyi

@@ -4,12 +4,13 @@
 
 from __future__ import annotations
 from numpy.typing import NDArray
+from types import ModuleType
 from typing import (Union, List, Tuple, Optional, Any, Literal, overload)
 
 from ._base import Compat
 from ._array import CompatArray
 from ..types import (
-    DTypeT, DeviceT, dtypeT, DType, AnyDevice,
+    dtypeT, DTypeT, deviceT, DeviceT, DType, AnyDevice,
     ValueT, Value, ArrayLike, ArrayOrAny
 )
 
@@ -81,17 +82,17 @@ class CompatNamespace(Compat):
         ...
 
     @overload
-    def arange(self, start: int, /, stop: Optional[int] = ..., step: int = ..., *, dtype: None = ..., device: None = ...) -> CompatArray[int, Literal["cpu"]]: ...
+    def arange(self, start: int, /, stop: Optional[int] = ..., step: int = ..., *, dtype: None = ..., device: None = ...) -> CompatArray[type[int], Literal["cpu"]]: ...
     @overload
-    def arange(self, start: Union[int, float], /, stop: Optional[Union[int, float]] = ..., step: Union[int, float] = ..., *, dtype: None = ..., device: None = ...) -> CompatArray[float, Literal["cpu"]]: ...
+    def arange(self, start: Union[int, float], /, stop: Optional[Union[int, float]] = ..., step: Union[int, float] = ..., *, dtype: None = ..., device: None = ...) -> CompatArray[type[float], Literal["cpu"]]: ...
     @overload
-    def arange(self, start: int, /, stop: Optional[int] = ..., step: int = ..., *, dtype: None = ..., device: DeviceT) -> CompatArray[int, DeviceT]: ...
+    def arange(self, start: int, /, stop: Optional[int] = ..., step: int = ..., *, dtype: None = ..., device: DeviceT) -> CompatArray[type[int], DeviceT]: ...
     @overload
-    def arange(self, start: int, /, stop: Optional[int] = ..., step: int = ..., *, dtype: None = ..., device: AnyDevice) -> CompatArray[int, AnyDevice]: ...
+    def arange(self, start: int, /, stop: Optional[int] = ..., step: int = ..., *, dtype: None = ..., device: AnyDevice) -> CompatArray[type[int], AnyDevice]: ...
     @overload
-    def arange(self, start: Union[int, float], /, stop: Optional[Union[int, float]] = ..., step: Union[int, float] = ..., *, dtype: None = ..., device: DeviceT) -> CompatArray[float, DeviceT]: ...
+    def arange(self, start: Union[int, float], /, stop: Optional[Union[int, float]] = ..., step: Union[int, float] = ..., *, dtype: None = ..., device: DeviceT) -> CompatArray[type[float], DeviceT]: ...
     @overload
-    def arange(self, start: Union[int, float], /, stop: Optional[Union[int, float]] = ..., step: Union[int, float] = ..., *, dtype: None = ..., device: AnyDevice) -> CompatArray[float, AnyDevice]: ...
+    def arange(self, start: Union[int, float], /, stop: Optional[Union[int, float]] = ..., step: Union[int, float] = ..., *, dtype: None = ..., device: AnyDevice) -> CompatArray[type[float], AnyDevice]: ...
     @overload
     def arange(self, start: Union[int, float], /, stop: Optional[Union[int, float]] = ..., step: Union[int, float] = ..., *, dtype: DTypeT, device: None = ...) -> CompatArray[DTypeT, Literal["cpu"]]: ...
     @overload
@@ -142,11 +143,11 @@ class CompatNamespace(Compat):
         ...
 
     @overload
-    def empty(self, shape: Union[int, Tuple[int, ...]], *, dtype: None = ..., device: None = ...) -> CompatArray[float, Literal["cpu"]]: ...
+    def empty(self, shape: Union[int, Tuple[int, ...]], *, dtype: None = ..., device: None = ...) -> CompatArray[type[float], Literal["cpu"]]: ...
     @overload
-    def empty(self, shape: Union[int, Tuple[int, ...]], *, dtype: None = ..., device: DeviceT) -> CompatArray[float, DeviceT]: ...
+    def empty(self, shape: Union[int, Tuple[int, ...]], *, dtype: None = ..., device: DeviceT) -> CompatArray[type[float], DeviceT]: ...
     @overload
-    def empty(self, shape: Union[int, Tuple[int, ...]], *, dtype: None = ..., device: AnyDevice) -> CompatArray[float, AnyDevice]: ...
+    def empty(self, shape: Union[int, Tuple[int, ...]], *, dtype: None = ..., device: AnyDevice) -> CompatArray[type[float], AnyDevice]: ...
     @overload
     def empty(self, shape: Union[int, Tuple[int, ...]], *, dtype: DTypeT, device: None = ...) -> CompatArray[DTypeT, Literal["cpu"]]: ...
     @overload
@@ -229,11 +230,11 @@ class CompatNamespace(Compat):
         ...
 
     @overload
-    def eye(self, n_rows: int, n_cols: Optional[int] = ..., /, *, k: int = ..., dtype: None = ..., device: None = ...) -> CompatArray[float, Literal["cpu"]]: ...
+    def eye(self, n_rows: int, n_cols: Optional[int] = ..., /, *, k: int = ..., dtype: None = ..., device: None = ...) -> CompatArray[type[float], Literal["cpu"]]: ...
     @overload
-    def eye(self, n_rows: int, n_cols: Optional[int] = ..., /, *, k: int = ..., dtype: None = ..., device: DeviceT) -> CompatArray[float, DeviceT]: ...
+    def eye(self, n_rows: int, n_cols: Optional[int] = ..., /, *, k: int = ..., dtype: None = ..., device: DeviceT) -> CompatArray[type[float], DeviceT]: ...
     @overload
-    def eye(self, n_rows: int, n_cols: Optional[int] = ..., /, *, k: int = ..., dtype: None = ..., device: AnyDevice) -> CompatArray[float, AnyDevice]: ...
+    def eye(self, n_rows: int, n_cols: Optional[int] = ..., /, *, k: int = ..., dtype: None = ..., device: AnyDevice) -> CompatArray[type[float], AnyDevice]: ...
     @overload
     def eye(self, n_rows: int, n_cols: Optional[int] = ..., /, *, k: int = ..., dtype: DTypeT, device: None = ...) -> CompatArray[DTypeT, Literal["cpu"]]: ...
     @overload
@@ -431,11 +432,11 @@ class CompatNamespace(Compat):
         ...
 
     @overload
-    def linspace(self, start: Union[int, float, complex], stop: Union[int, float, complex], /, num: int, *, dtype: None = ..., device: None = ..., endpoint: bool = ...) -> CompatArray[float, Literal["cpu"]]: ...
+    def linspace(self, start: Union[int, float, complex], stop: Union[int, float, complex], /, num: int, *, dtype: None = ..., device: None = ..., endpoint: bool = ...) -> CompatArray[type[float], Literal["cpu"]]: ...
     @overload
-    def linspace(self, start: Union[int, float, complex], stop: Union[int, float, complex], /, num: int, *, dtype: None = ..., device: DeviceT, endpoint: bool = ...) -> CompatArray[float, DeviceT]: ...
+    def linspace(self, start: Union[int, float, complex], stop: Union[int, float, complex], /, num: int, *, dtype: None = ..., device: DeviceT, endpoint: bool = ...) -> CompatArray[type[float], DeviceT]: ...
     @overload
-    def linspace(self, start: Union[int, float, complex], stop: Union[int, float, complex], /, num: int, *, dtype: None = ..., device: AnyDevice, endpoint: bool = ...) -> CompatArray[float, AnyDevice]: ...
+    def linspace(self, start: Union[int, float, complex], stop: Union[int, float, complex], /, num: int, *, dtype: None = ..., device: AnyDevice, endpoint: bool = ...) -> CompatArray[type[float], AnyDevice]: ...
     @overload
     def linspace(self, start: Union[int, float, complex], stop: Union[int, float, complex], /, num: int, *, dtype: DTypeT, device: None = ..., endpoint: bool = ...) -> CompatArray[DTypeT, Literal["cpu"]]: ...
     @overload
@@ -496,11 +497,11 @@ class CompatNamespace(Compat):
     def meshgrid(self, *arrays: ArrayLike[Any], indexing: Literal["xy", "ij"] = "xy") -> List[CompatArray[Any, AnyDevice]]: ...
 
     @overload
-    def ones(self, shape: Union[int, Tuple[int, ...]], *, dtype: None = ..., device: None = ...) -> CompatArray[float, Literal["cpu"]]: ...
+    def ones(self, shape: Union[int, Tuple[int, ...]], *, dtype: None = ..., device: None = ...) -> CompatArray[type[float], Literal["cpu"]]: ...
     @overload
-    def ones(self, shape: Union[int, Tuple[int, ...]], *, dtype: None = ..., device: DeviceT) -> CompatArray[float, DeviceT]: ...
+    def ones(self, shape: Union[int, Tuple[int, ...]], *, dtype: None = ..., device: DeviceT) -> CompatArray[type[float], DeviceT]: ...
     @overload
-    def ones(self, shape: Union[int, Tuple[int, ...]], *, dtype: None = ..., device: AnyDevice) -> CompatArray[float, AnyDevice]: ...
+    def ones(self, shape: Union[int, Tuple[int, ...]], *, dtype: None = ..., device: AnyDevice) -> CompatArray[type[float], AnyDevice]: ...
     @overload
     def ones(self, shape: Union[int, Tuple[int, ...]], *, dtype: DTypeT, device: None = ...) -> CompatArray[DTypeT, Literal["cpu"]]: ...
     @overload
@@ -648,11 +649,11 @@ class CompatNamespace(Compat):
         ...
 
     @overload
-    def zeros(self, shape: Union[int, Tuple[int, ...]], *, dtype: None = ..., device: None = ...) -> CompatArray[float, Literal["cpu"]]: ...
+    def zeros(self, shape: Union[int, Tuple[int, ...]], *, dtype: None = ..., device: None = ...) -> CompatArray[type[float], Literal["cpu"]]: ...
     @overload
-    def zeros(self, shape: Union[int, Tuple[int, ...]], *, dtype: None = ..., device: DeviceT) -> CompatArray[float, DeviceT]: ...
+    def zeros(self, shape: Union[int, Tuple[int, ...]], *, dtype: None = ..., device: DeviceT) -> CompatArray[type[float], DeviceT]: ...
     @overload
-    def zeros(self, shape: Union[int, Tuple[int, ...]], *, dtype: None = ..., device: AnyDevice) -> CompatArray[float, AnyDevice]: ...
+    def zeros(self, shape: Union[int, Tuple[int, ...]], *, dtype: None = ..., device: AnyDevice) -> CompatArray[type[float], AnyDevice]: ...
     @overload
     def zeros(self, shape: Union[int, Tuple[int, ...]], *, dtype: DTypeT, device: None = ...) -> CompatArray[DTypeT, Literal["cpu"]]: ...
     @overload
@@ -802,7 +803,7 @@ class CompatNamespace(Compat):
         Returns
         -------
             CompatArray
-                A :class:`CompatArray` output array containing the concatenated values. 
+                A :class:`CompatArray` output array containing the concatenated values.
         """
         ...
 
@@ -841,6 +842,26 @@ class CompatNamespace(Compat):
         """
         ...
 
+    # === Linear Algebra Extension ===
+    @overload
+    def vector_norm(self, x: NDArray[Any], /, *, axis: Optional[Union[int, Tuple[int, ...]]] = ..., keepdims: bool = ..., ord: Union[int, float, Literal["inf", "-inf"]] = ...) -> CompatArray[type[float], Literal["cpu"]]: ...
+    @overload
+    def vector_norm(self, x: CompatArray[Any, deviceT], /, *, axis: Optional[Union[int, Tuple[int, ...]]] = ..., keepdims: bool = ..., ord: Union[int, float, Literal["inf", "-inf"]] = ...) -> CompatArray[type[float], deviceT]: ...
+    @overload
+    def vector_norm(self, x: ArrayLike[Any], /, *, axis: Optional[Union[int, Tuple[int, ...]]] = ..., keepdims: bool = ..., ord: Union[int, float, Literal["inf", "-inf"]] = ...) -> CompatArray[type[float], AnyDevice]: ...
+    def vector_norm(self, x: ArrayLike[Any], /, *, axis: Optional[Union[int, Tuple[int, ...]]] = None, keepdims: bool = False, ord: Union[int, float, Literal["inf", "-inf"]] = 2) -> CompatArray[type[float], AnyDevice]: ...
+
+    @overload
+    def matrix_norm(self, x: NDArray[Any], /, *, keepdims: bool = ..., ord: Optional[Union[int, float, Literal["inf", "-inf", "fro", "nuc"]]] = ...) -> CompatArray[type[float], Literal["cpu"]]: ...
+    @overload
+    def matrix_norm(self, x: CompatArray[Any, deviceT], /, *, keepdims: bool = ..., ord: Optional[Union[int, float, Literal["inf", "-inf", "fro", "nuc"]]] = ...) -> CompatArray[type[float], deviceT]: ...
+    @overload
+    def matrix_norm(self, x: ArrayLike[Any], /, *, keepdims: bool = ..., ord: Optional[Union[int, float, Literal["inf", "-inf", "fro", "nuc"]]] = ...) -> CompatArray[type[float], AnyDevice]: ...
+    def matrix_norm(self, x: ArrayLike[Any], /, *, keepdims: bool = False, ord: Optional[Union[int, float, Literal["inf", "-inf", "fro", "nuc"]]] = "fro") -> CompatArray[type[float], AnyDevice]: ...
+
+    @property
+    def linalg(self) -> ModuleType: ...
+
     # === Constants ===
     @property
     def e(self) -> float: ...
@@ -883,3 +904,5 @@ class CompatNamespace(Compat):
 
     @property
     def __name__(self) -> str: ...
+
+    def __getattr__(self, name: str) -> Any: ...

{cobra_array-0.2.0 → cobra_array-0.2.2}/src/cobra_array/convert.py

@@ -122,11 +122,11 @@ def to_tensor(obj, /, *, dtype=None, device=None, copy=True):
             - `None`: Raises `ConvertNoneTypeError`;
             - _others_: Converted to a `PyTorch tensor` directly.
 
-        dtype : Optional[DTypeT], default to `None`
+        dtype : Optional[DType], default to `None`
             The data type of the resulting `PyTorch tensor`.
             - `None`: Use the default data type of the object.
 
-        device : Optional[DeviceT], default to `None`
+        device : Optional[AnyDevice], default to `None`
             The device on which the resulting `PyTorch tensor` will be allocated.
             - `None`: Use the default device (usually `"cpu"`).
 
@@ -294,11 +294,11 @@ def as_array(obj, xp, /, *, dtype=None, device=None, copy=False, arraylike_only=
             - _ArrayLibraryName_ (`"numpy"` or `"torch"`): Converted to a `NumPy array` or `PyTorch tensor` respectively using the corresponding conversion functions;
             - _Namespace_ or _CompatNamespace_: Converted to an array using the `asarray()` function provided by the namespace module, which must be compatible with the array API standard.
 
-        dtype : Optional[DTypeT], default to `None`
+        dtype : Optional[DType], default to `None`
             The data type of the resulting array.
             - `None`: Use the default data type of the object.
 
-        device : Optional[DeviceT], default to `None`
+        device : Optional[AnyDevice], default to `None`
             The device on which the resulting array will be allocated (only if `array namespace` supports it).
 
         copy : bool, default to `False`

{cobra_array-0.2.0 → cobra_array-0.2.2}/src/cobra_array/types.py

@@ -24,8 +24,9 @@ Device = Union[DeviceLiteral, torch.device]
 AnyDevice = Union[Device, str]
 
 dtypeT = TypeVar("dtypeT", bound=DType)
-deviceT = TypeVar("deviceT", bound=Device)
-anydeviceT = TypeVar("anydeviceT", bound=AnyDevice)
+deviceT = TypeVar("deviceT", bound=AnyDevice)
+# anydeviceT = TypeVar("anydeviceT", bound=AnyDevice)
+
 DTypeT = TypeVar("DTypeT", bound=DType)
 DeviceT = TypeVar("DeviceT", bound=Device)
 AnyDeviceT = TypeVar("AnyDeviceT", bound=AnyDevice)
@@ -55,16 +56,16 @@ ArrayOrInt = Union[ArrayLike[Any], int]
 
 class UniqueAllResult(NamedTuple, Generic[DTypeT_co, AnyDeviceT_co]):
     values: CompatArray[DTypeT_co, AnyDeviceT_co]
-    indices: CompatArray[int, AnyDeviceT_co]
-    inverse_indices: CompatArray[int, AnyDeviceT_co]
-    counts: CompatArray[int, AnyDeviceT_co]
+    indices: CompatArray[type[int], AnyDeviceT_co]
+    inverse_indices: CompatArray[type[int], AnyDeviceT_co]
+    counts: CompatArray[type[int], AnyDeviceT_co]
 
 
 class UniqueCountsResult(NamedTuple, Generic[DTypeT_co, AnyDeviceT_co]):
     values: CompatArray[DTypeT_co, AnyDeviceT_co]
-    counts: CompatArray[int, AnyDeviceT_co]
+    counts: CompatArray[type[int], AnyDeviceT_co]
 
 
 class UniqueInverseResult(NamedTuple, Generic[DTypeT_co, AnyDeviceT_co]):
     values: CompatArray[DTypeT_co, AnyDeviceT_co]
-    inverse_indices: CompatArray[int, AnyDeviceT_co]
+    inverse_indices: CompatArray[type[int], AnyDeviceT_co]

{cobra_array-0.2.0 → cobra_array-0.2.2/src/cobra_array.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cobra-array
-Version: 0.2.0
+Version: 0.2.2
 Summary: A backend-agnostic array utility library that unifies array conversion, context control, and cross-library operations across `NumPy`/`PyTorch`-style ecosystems.
 Author-email: Zhen Tian <zhen.tian.cs@gmail.com>
 Project-URL: Homepage, https://github.com/tinchen777/cobra-array.git

{cobra_array-0.2.0 → cobra_array-0.2.2}/tests/test_compat.py

@@ -67,10 +67,17 @@ def test_to_device_on_numpy_backend():
 @pytest.mark.skipif(torch_xp is None, reason="PyTorch not available")
 def test_to_tensor_available_backend():
     a = _arr_1d()
+    
+    aa = a.to_device("cpu")
+    
+    aa = CompatArray(a)
+    
     t = a.to_tensor(device="cpu")
 
     assert isinstance(t, torch_xp.Tensor)
     assert tuple(t.shape) == (3,)
+    
+    aa = wrap_arraylike(a)
 
 
 def test_unstack_and_nonzero():
@@ -78,6 +85,15 @@ def test_unstack_and_nonzero():
 
     pieces = a.unstack(axis=0)
     nz = a.nonzero()
+    
+    ff = CompatArray(nz[0])
+    
+    fff = a.cxp.zeros((1,2))
+    
+    ff = CompatArray(fff)
+    
+    gg = a.argmax()
+    
 
     assert isinstance(pieces, tuple)
     assert len(pieces) == 2
@@ -470,13 +486,47 @@ def test_cxp_of_compatarray_matches_array_namespace():
     assert cxp.xp_name == a.xp_name
 
 
+def test_linalg():
+    a = CompatArray(np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32))
+    cxp = a.cxp
+    print(a)
+
+    f = cxp.vector_norm(a, axis=0, ord="-inf")
+
+    print(f)
+
+    f = cxp.matrix_norm(a, ord="nuc")
+
+    print(f)
+
+# def test_linalg2():
+#     import torch
+#     a = CompatArray(torch.tensor([[1.0, 2.0], [3.0, 4.0]], device="cuda:0"))
+#     cxp = a.cxp
+#     print(a)
+
+#     f = cxp.vector_norm(a, axis=0, ord="-inf")
+
+#     print(f.device)
+
+#     print(f)
+
+#     f = cxp.matrix_norm(a, ord="nuc")
+
+#     print(f)
+#     print(f.device)
+
+
 if __name__ == "__main__":
-    test_unique_all_unique_counts_unique_inverse()
-    print("=" * 40)
+    # test_unique_all_unique_counts_unique_inverse()
+    # print("=" * 40)
     
-    test_numpy_operator_overloads()
-    print("=" * 40)
+    # test_numpy_operator_overloads()
+    # print("=" * 40)
     # test_torch_operator_overloads()
-    print("=" * 40)
+    # print("=" * 40)
 
-    test_add()
+    # test_add()
+    
+    # test_linalg2()
+    pass