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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cobra-array
-Version: 0.2.0
+Version: 0.2.1
 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.1}/src/cobra_array/__init__.py

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

{cobra_array-0.2.0 → cobra_array-0.2.1}/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.1}/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 ===
@@ -1771,6 +1770,8 @@ 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]: ...

{cobra_array-0.2.0 → cobra_array-0.2.1}/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.1}/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
 )
 
@@ -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[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[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[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[float, AnyDevice]: ...
+
+    @overload
+    def matrix_norm(self, x: NDArray[Any], /, *, keepdims: bool = ..., ord: Optional[Union[int, float, Literal["inf", "-inf", "fro", "nuc"]]] = ...) -> CompatArray[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[float, deviceT]: ...
+    @overload
+    def matrix_norm(self, x: ArrayLike[Any], /, *, keepdims: bool = ..., ord: Optional[Union[int, float, Literal["inf", "-inf", "fro", "nuc"]]] = ...) -> CompatArray[float, AnyDevice]: ...
+    def matrix_norm(self, x: ArrayLike[Any], /, *, keepdims: bool = False, ord: Optional[Union[int, float, Literal["inf", "-inf", "fro", "nuc"]]] = "fro") -> CompatArray[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.1}/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.1}/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)

{cobra_array-0.2.0 → cobra_array-0.2.1/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.1
 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.1}/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():
@@ -470,13 +477,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