gpuarray 0.1.0__tar.gz → 0.2.0__tar.gz

{gpuarray-0.1.0 → gpuarray-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gpuarray
-Version: 0.1.0
+Version: 0.2.0
 Summary: NumPy-like GPU array library that works on every GPU — NVIDIA, AMD, Intel, Apple Silicon. No CUDA required.
 Author: Arnav Kewalram
 License: MIT

{gpuarray-0.1.0 → gpuarray-0.2.0}/gpuarray/__init__.py

@@ -20,6 +20,13 @@ from .api import (
     relu,
     sigmoid,
     tanh,
+    where,
+    clip,
+    argmax,
+    argmin,
+    concatenate,
+    stack,
+    random,
 )
 
 __version__ = "0.1.0"
@@ -44,4 +51,11 @@ __all__ = [
     "relu",
     "sigmoid",
     "tanh",
+    "where",
+    "clip",
+    "argmax",
+    "argmin",
+    "concatenate",
+    "stack",
+    "random",
 ]

gpuarray-0.2.0/gpuarray/api.py

@@ -0,0 +1,182 @@
+"""NumPy-compatible module-level functions."""
+
+from __future__ import annotations
+
+from typing import Sequence
+
+import numpy as np
+
+from .core import GPUArray, _from_numpy, matmul as _matmul
+from . import shaders
+
+
+# ----- creation functions -----
+
+def array(data) -> GPUArray:
+    """Create a GPUArray from a list, nested list, or numpy array."""
+    if isinstance(data, GPUArray):
+        return data
+    arr = np.asarray(data, dtype=np.float32)
+    if arr.ndim == 0:
+        arr = arr.reshape((1,))
+    return _from_numpy(arr)
+
+
+def zeros(shape) -> GPUArray:
+    if isinstance(shape, int):
+        shape = (shape,)
+    return _from_numpy(np.zeros(shape, dtype=np.float32))
+
+
+def ones(shape) -> GPUArray:
+    if isinstance(shape, int):
+        shape = (shape,)
+    return _from_numpy(np.ones(shape, dtype=np.float32))
+
+
+def arange(start, stop=None, step=1) -> GPUArray:
+    if stop is None:
+        stop = start
+        start = 0
+    return _from_numpy(np.arange(start, stop, step, dtype=np.float32))
+
+
+def linspace(start, stop, num=50) -> GPUArray:
+    return _from_numpy(np.linspace(start, stop, num, dtype=np.float32))
+
+
+# ----- operations -----
+
+def dot(a: GPUArray, b: GPUArray):
+    return a.dot(b)
+
+
+def matmul(a: GPUArray, b: GPUArray) -> GPUArray:
+    return _matmul(a, b)
+
+
+def sum(a: GPUArray) -> float:
+    return a.sum()
+
+
+def mean(a: GPUArray) -> float:
+    return a.mean()
+
+
+def exp(a: GPUArray) -> GPUArray:
+    return a._run_unary_op(shaders.EXP_SHADER)
+
+
+def log(a: GPUArray) -> GPUArray:
+    return a._run_unary_op(shaders.LOG_SHADER)
+
+
+def sqrt(a: GPUArray) -> GPUArray:
+    return a._run_unary_op(shaders.SQRT_SHADER)
+
+
+def abs(a: GPUArray) -> GPUArray:
+    return a._run_unary_op(shaders.ABS_SHADER)
+
+
+def max(a: GPUArray) -> float:
+    return a.max()
+
+
+def min(a: GPUArray) -> float:
+    return a.min()
+
+
+def relu(a: GPUArray) -> GPUArray:
+    return a._run_unary_op(shaders.RELU_SHADER)
+
+
+def sigmoid(a: GPUArray) -> GPUArray:
+    return a._run_unary_op(shaders.SIGMOID_SHADER)
+
+
+def tanh(a: GPUArray) -> GPUArray:
+    return a._run_unary_op(shaders.TANH_SHADER)
+
+
+# ----- new operations -----
+
+def where(condition: GPUArray, x: GPUArray, y: GPUArray) -> GPUArray:
+    """Conditional select: where condition is 1.0, pick x; else pick y."""
+    import wgpu
+    from .device import get_device
+    from .core import _get_pipeline
+
+    assert condition.size == x.size == y.size
+    device = get_device()
+    _, pipeline = _get_pipeline(shaders.WHERE_SHADER)
+
+    out_buf = device.create_buffer(
+        size=condition.size * 4,
+        usage=wgpu.BufferUsage.STORAGE | wgpu.BufferUsage.COPY_SRC | wgpu.BufferUsage.COPY_DST,
+    )
+    bind_group = device.create_bind_group(
+        layout=pipeline.get_bind_group_layout(0),
+        entries=[
+            {"binding": 0, "resource": {"buffer": condition._buffer, "offset": 0, "size": condition.size * 4}},
+            {"binding": 1, "resource": {"buffer": x._buffer, "offset": 0, "size": x.size * 4}},
+            {"binding": 2, "resource": {"buffer": y._buffer, "offset": 0, "size": y.size * 4}},
+            {"binding": 3, "resource": {"buffer": out_buf, "offset": 0, "size": condition.size * 4}},
+        ],
+    )
+    import math
+    n_workgroups = math.ceil(condition.size / 256)
+    encoder = device.create_command_encoder()
+    pass_enc = encoder.begin_compute_pass()
+    pass_enc.set_pipeline(pipeline)
+    pass_enc.set_bind_group(0, bind_group)
+    pass_enc.dispatch_workgroups(n_workgroups)
+    pass_enc.end()
+    device.queue.submit([encoder.finish()])
+    return GPUArray(out_buf, condition._shape)
+
+
+def clip(a: GPUArray, min_val: float, max_val: float) -> GPUArray:
+    """Clamp values to [min_val, max_val]."""
+    return a.clip(min_val, max_val)
+
+
+def argmax(a: GPUArray) -> int:
+    """Return index of maximum value."""
+    return a.argmax()
+
+
+def argmin(a: GPUArray) -> int:
+    """Return index of minimum value."""
+    return a.argmin()
+
+
+def concatenate(arrays, axis: int = 0) -> GPUArray:
+    """Join arrays along an axis (CPU-side, creates new GPU buffer)."""
+    np_arrays = [a.to_numpy() for a in arrays]
+    result = np.concatenate(np_arrays, axis=axis)
+    return _from_numpy(result)
+
+
+def stack(arrays, axis: int = 0) -> GPUArray:
+    """Stack arrays along a new axis (CPU-side, creates new GPU buffer)."""
+    np_arrays = [a.to_numpy() for a in arrays]
+    result = np.stack(np_arrays, axis=axis)
+    return _from_numpy(result)
+
+
+# ----- random submodule -----
+
+class _Random:
+    """Random array generation (CPU-side, uploaded to GPU)."""
+
+    def rand(self, *shape) -> GPUArray:
+        """Uniform random values in [0, 1)."""
+        return _from_numpy(np.random.rand(*shape).astype(np.float32))
+
+    def randn(self, *shape) -> GPUArray:
+        """Standard normal random values."""
+        return _from_numpy(np.random.randn(*shape).astype(np.float32))
+
+
+random = _Random()

{gpuarray-0.1.0 → gpuarray-0.2.0}/gpuarray/core.py

@@ -343,6 +343,105 @@ class GPUArray:
             raise ValueError(f"Cannot reshape array of size {self.size} into shape {new_shape}")
         return GPUArray(self._buffer, new_shape)
 
+    # ----- clamp / clip -----
+
+    def clip(self, min_val: float, max_val: float) -> "GPUArray":
+        """Clamp values to [min_val, max_val]."""
+        device = get_device()
+        _, pipeline = _get_pipeline(shaders.CLAMP_SHADER)
+
+        out_buf = device.create_buffer(
+            size=self.size * 4,
+            usage=wgpu.BufferUsage.STORAGE | wgpu.BufferUsage.COPY_SRC | wgpu.BufferUsage.COPY_DST,
+        )
+        # Pack two f32 values, padded to 16 bytes
+        params_data = struct.pack("ff", min_val, max_val) + b"\x00" * 8
+        uniform_buf = device.create_buffer_with_data(
+            data=params_data,
+            usage=wgpu.BufferUsage.UNIFORM,
+        )
+        bind_group = device.create_bind_group(
+            layout=pipeline.get_bind_group_layout(0),
+            entries=[
+                {"binding": 0, "resource": {"buffer": self._buffer, "offset": 0, "size": self.size * 4}},
+                {"binding": 1, "resource": {"buffer": out_buf, "offset": 0, "size": self.size * 4}},
+                {"binding": 2, "resource": {"buffer": uniform_buf, "offset": 0, "size": 16}},
+            ],
+        )
+        n_workgroups = math.ceil(self.size / WORKGROUP_SIZE)
+        encoder = device.create_command_encoder()
+        pass_enc = encoder.begin_compute_pass()
+        pass_enc.set_pipeline(pipeline)
+        pass_enc.set_bind_group(0, bind_group)
+        pass_enc.dispatch_workgroups(n_workgroups)
+        pass_enc.end()
+        device.queue.submit([encoder.finish()])
+        uniform_buf.destroy()
+        return GPUArray(out_buf, self._shape)
+
+    # ----- argmax / argmin -----
+
+    def argmax(self) -> int:
+        """Return index of maximum value (as Python int)."""
+        data = self.to_numpy().flatten()
+        return int(np.argmax(data))
+
+    def argmin(self) -> int:
+        """Return index of minimum value (as Python int)."""
+        data = self.to_numpy().flatten()
+        return int(np.argmin(data))
+
+    # ----- copy -----
+
+    def copy(self) -> "GPUArray":
+        """Return a copy of this array."""
+        return self._run_unary_op(shaders.COPY_SHADER)
+
+    # ----- comparison operators -----
+
+    def __eq__(self, other):
+        if isinstance(other, (int, float)):
+            other = _from_numpy(np.full(self.size, other, dtype=np.float32).reshape(self._shape))
+        return self._run_binary_op(other, shaders.EQ_SHADER)
+
+    def __gt__(self, other):
+        if isinstance(other, (int, float)):
+            other = _from_numpy(np.full(self.size, other, dtype=np.float32).reshape(self._shape))
+        return self._run_binary_op(other, shaders.GT_SHADER)
+
+    def __lt__(self, other):
+        if isinstance(other, (int, float)):
+            other = _from_numpy(np.full(self.size, other, dtype=np.float32).reshape(self._shape))
+        return self._run_binary_op(other, shaders.LT_SHADER)
+
+    def __ge__(self, other):
+        if isinstance(other, (int, float)):
+            other = _from_numpy(np.full(self.size, other, dtype=np.float32).reshape(self._shape))
+        return self._run_binary_op(other, shaders.GE_SHADER)
+
+    def __le__(self, other):
+        if isinstance(other, (int, float)):
+            other = _from_numpy(np.full(self.size, other, dtype=np.float32).reshape(self._shape))
+        return self._run_binary_op(other, shaders.LE_SHADER)
+
+    # ----- power -----
+
+    def __pow__(self, other):
+        if isinstance(other, (int, float)):
+            other = _from_numpy(np.full(self.size, other, dtype=np.float32).reshape(self._shape))
+        return self._run_binary_op(other, shaders.POW_SHADER)
+
+    # ----- flatten -----
+
+    def flatten(self) -> "GPUArray":
+        """Return a 1D view of the array."""
+        return GPUArray(self._buffer, (self.size,))
+
+    # ----- len -----
+
+    def __len__(self) -> int:
+        return self._shape[0]
+
 
 def _from_numpy(data: np.ndarray) -> GPUArray:
     """Create a GPUArray from a numpy array."""

{gpuarray-0.1.0 → gpuarray-0.2.0}/gpuarray/shaders.py

@@ -424,3 +424,177 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
     c[row * dims.N + col] = sum;
 }
 """
+
+# ---------------------------------------------------------------------------
+# Clamp (requires uniform buffer with min_val, max_val)
+# ---------------------------------------------------------------------------
+
+CLAMP_SHADER = """
+struct Params {
+    min_val: f32,
+    max_val: f32,
+}
+
+@group(0) @binding(0) var<storage, read> a: array<f32>;
+@group(0) @binding(1) var<storage, read_write> result: array<f32>;
+@group(0) @binding(2) var<uniform> params: Params;
+
+@compute @workgroup_size(256)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let i = gid.x;
+    if (i < arrayLength(&a)) {
+        result[i] = clamp(a[i], params.min_val, params.max_val);
+    }
+}
+"""
+
+# ---------------------------------------------------------------------------
+# Where / select: result = cond * a + (1-cond) * b
+# ---------------------------------------------------------------------------
+
+WHERE_SHADER = """
+@group(0) @binding(0) var<storage, read> cond: array<f32>;
+@group(0) @binding(1) var<storage, read> a: array<f32>;
+@group(0) @binding(2) var<storage, read> b: array<f32>;
+@group(0) @binding(3) var<storage, read_write> result: array<f32>;
+
+@compute @workgroup_size(256)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let i = gid.x;
+    if (i < arrayLength(&cond)) {
+        result[i] = cond[i] * a[i] + (1.0 - cond[i]) * b[i];
+    }
+}
+"""
+
+# ---------------------------------------------------------------------------
+# Comparison shaders (return 0.0 or 1.0)
+# ---------------------------------------------------------------------------
+
+EQ_SHADER = """
+@group(0) @binding(0) var<storage, read> a: array<f32>;
+@group(0) @binding(1) var<storage, read> b: array<f32>;
+@group(0) @binding(2) var<storage, read_write> result: array<f32>;
+
+@compute @workgroup_size(256)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let i = gid.x;
+    if (i < arrayLength(&a)) {
+        if (a[i] == b[i]) {
+            result[i] = 1.0;
+        } else {
+            result[i] = 0.0;
+        }
+    }
+}
+"""
+
+GT_SHADER = """
+@group(0) @binding(0) var<storage, read> a: array<f32>;
+@group(0) @binding(1) var<storage, read> b: array<f32>;
+@group(0) @binding(2) var<storage, read_write> result: array<f32>;
+
+@compute @workgroup_size(256)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let i = gid.x;
+    if (i < arrayLength(&a)) {
+        if (a[i] > b[i]) {
+            result[i] = 1.0;
+        } else {
+            result[i] = 0.0;
+        }
+    }
+}
+"""
+
+LT_SHADER = """
+@group(0) @binding(0) var<storage, read> a: array<f32>;
+@group(0) @binding(1) var<storage, read> b: array<f32>;
+@group(0) @binding(2) var<storage, read_write> result: array<f32>;
+
+@compute @workgroup_size(256)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let i = gid.x;
+    if (i < arrayLength(&a)) {
+        if (a[i] < b[i]) {
+            result[i] = 1.0;
+        } else {
+            result[i] = 0.0;
+        }
+    }
+}
+"""
+
+GE_SHADER = """
+@group(0) @binding(0) var<storage, read> a: array<f32>;
+@group(0) @binding(1) var<storage, read> b: array<f32>;
+@group(0) @binding(2) var<storage, read_write> result: array<f32>;
+
+@compute @workgroup_size(256)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let i = gid.x;
+    if (i < arrayLength(&a)) {
+        if (a[i] >= b[i]) {
+            result[i] = 1.0;
+        } else {
+            result[i] = 0.0;
+        }
+    }
+}
+"""
+
+LE_SHADER = """
+@group(0) @binding(0) var<storage, read> a: array<f32>;
+@group(0) @binding(1) var<storage, read> b: array<f32>;
+@group(0) @binding(2) var<storage, read_write> result: array<f32>;
+
+@compute @workgroup_size(256)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let i = gid.x;
+    if (i < arrayLength(&a)) {
+        if (a[i] <= b[i]) {
+            result[i] = 1.0;
+        } else {
+            result[i] = 0.0;
+        }
+    }
+}
+"""
+
+# ---------------------------------------------------------------------------
+# Fill (fill array with uniform scalar)
+# ---------------------------------------------------------------------------
+
+FILL_SHADER = """
+struct Params {
+    scalar: f32,
+}
+
+@group(0) @binding(0) var<storage, read_write> result: array<f32>;
+@group(0) @binding(1) var<uniform> params: Params;
+
+@compute @workgroup_size(256)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let i = gid.x;
+    if (i < arrayLength(&result)) {
+        result[i] = params.scalar;
+    }
+}
+"""
+
+# ---------------------------------------------------------------------------
+# Copy
+# ---------------------------------------------------------------------------
+
+COPY_SHADER = """
+@group(0) @binding(0) var<storage, read> a: array<f32>;
+@group(0) @binding(1) var<storage, read_write> result: array<f32>;
+
+@compute @workgroup_size(256)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let i = gid.x;
+    if (i < arrayLength(&a)) {
+        result[i] = a[i];
+    }
+}
+"""

{gpuarray-0.1.0 → gpuarray-0.2.0}/gpuarray.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gpuarray
-Version: 0.1.0
+Version: 0.2.0
 Summary: NumPy-like GPU array library that works on every GPU — NVIDIA, AMD, Intel, Apple Silicon. No CUDA required.
 Author: Arnav Kewalram
 License: MIT

{gpuarray-0.1.0 → gpuarray-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gpuarray"
-version = "0.1.0"
+version = "0.2.0"
 description = "NumPy-like GPU array library that works on every GPU — NVIDIA, AMD, Intel, Apple Silicon. No CUDA required."
 requires-python = ">=3.10,<3.14"
 license = {text = "MIT"}

{gpuarray-0.1.0 → gpuarray-0.2.0}/tests/test_core.py

@@ -225,3 +225,211 @@ class TestMisc:
     def test_getitem(self):
         a = gp.array([10, 20, 30])
         assert a[1] == 20.0
+
+
+class TestClip:
+    def test_clip_basic(self):
+        a_np = np.array([-2, -1, 0, 1, 2, 3, 4, 5], dtype=np.float32)
+        a = gp.array(a_np)
+        result = a.clip(0.0, 3.0)
+        expected = np.clip(a_np, 0.0, 3.0)
+        npt.assert_allclose(result.to_numpy(), expected, rtol=RTOL)
+
+    def test_clip_api(self):
+        a_np = np.array([1, 5, 10, -3], dtype=np.float32)
+        a = gp.array(a_np)
+        result = gp.clip(a, 0.0, 7.0)
+        expected = np.clip(a_np, 0.0, 7.0)
+        npt.assert_allclose(result.to_numpy(), expected, rtol=RTOL)
+
+
+class TestArgmaxArgmin:
+    def test_argmax(self):
+        a_np = np.array([1, 5, 3, 9, 2], dtype=np.float32)
+        a = gp.array(a_np)
+        assert a.argmax() == int(np.argmax(a_np))
+
+    def test_argmin(self):
+        a_np = np.array([3, 1, 4, 0, 5], dtype=np.float32)
+        a = gp.array(a_np)
+        assert a.argmin() == int(np.argmin(a_np))
+
+    def test_argmax_api(self):
+        a_np = np.array([10, 20, 5], dtype=np.float32)
+        a = gp.array(a_np)
+        assert gp.argmax(a) == 1
+
+    def test_argmin_api(self):
+        a_np = np.array([10, 20, 5], dtype=np.float32)
+        a = gp.array(a_np)
+        assert gp.argmin(a) == 2
+
+
+class TestComparisons:
+    def test_eq(self):
+        a = gp.array([1.0, 2.0, 3.0])
+        b = gp.array([1.0, 5.0, 3.0])
+        result = (a == b).to_numpy()
+        expected = np.array([1.0, 0.0, 1.0], dtype=np.float32)
+        npt.assert_allclose(result, expected, rtol=RTOL)
+
+    def test_gt(self):
+        a = gp.array([1.0, 5.0, 3.0])
+        b = gp.array([2.0, 3.0, 3.0])
+        result = (a > b).to_numpy()
+        expected = np.array([0.0, 1.0, 0.0], dtype=np.float32)
+        npt.assert_allclose(result, expected, rtol=RTOL)
+
+    def test_lt(self):
+        a = gp.array([1.0, 5.0, 3.0])
+        b = gp.array([2.0, 3.0, 3.0])
+        result = (a < b).to_numpy()
+        expected = np.array([1.0, 0.0, 0.0], dtype=np.float32)
+        npt.assert_allclose(result, expected, rtol=RTOL)
+
+    def test_ge(self):
+        a = gp.array([1.0, 5.0, 3.0])
+        b = gp.array([2.0, 3.0, 3.0])
+        result = (a >= b).to_numpy()
+        expected = np.array([0.0, 1.0, 1.0], dtype=np.float32)
+        npt.assert_allclose(result, expected, rtol=RTOL)
+
+    def test_le(self):
+        a = gp.array([1.0, 5.0, 3.0])
+        b = gp.array([2.0, 3.0, 3.0])
+        result = (a <= b).to_numpy()
+        expected = np.array([1.0, 0.0, 1.0], dtype=np.float32)
+        npt.assert_allclose(result, expected, rtol=RTOL)
+
+    def test_eq_scalar(self):
+        a = gp.array([1.0, 2.0, 3.0])
+        result = (a == 2.0).to_numpy()
+        expected = np.array([0.0, 1.0, 0.0], dtype=np.float32)
+        npt.assert_allclose(result, expected, rtol=RTOL)
+
+    def test_gt_scalar(self):
+        a = gp.array([1.0, 2.0, 3.0])
+        result = (a > 1.5).to_numpy()
+        expected = np.array([0.0, 1.0, 1.0], dtype=np.float32)
+        npt.assert_allclose(result, expected, rtol=RTOL)
+
+
+class TestWhere:
+    def test_where_basic(self):
+        cond = gp.array([1.0, 0.0, 1.0, 0.0])
+        x = gp.array([10.0, 20.0, 30.0, 40.0])
+        y = gp.array([50.0, 60.0, 70.0, 80.0])
+        result = gp.where(cond, x, y)
+        expected = np.array([10.0, 60.0, 30.0, 80.0], dtype=np.float32)
+        npt.assert_allclose(result.to_numpy(), expected, rtol=RTOL)
+
+    def test_where_from_comparison(self):
+        a = gp.array([1.0, 5.0, 3.0, 8.0])
+        cond = a > 3.0
+        x = gp.array([100.0, 100.0, 100.0, 100.0])
+        y = gp.array([0.0, 0.0, 0.0, 0.0])
+        result = gp.where(cond, x, y)
+        expected = np.array([0.0, 100.0, 0.0, 100.0], dtype=np.float32)
+        npt.assert_allclose(result.to_numpy(), expected, rtol=RTOL)
+
+
+class TestConcatenate:
+    def test_concat_1d(self):
+        a = gp.array([1.0, 2.0, 3.0])
+        b = gp.array([4.0, 5.0, 6.0])
+        result = gp.concatenate([a, b])
+        expected = np.array([1, 2, 3, 4, 5, 6], dtype=np.float32)
+        npt.assert_allclose(result.to_numpy(), expected, rtol=RTOL)
+        assert result.shape == (6,)
+
+    def test_concat_2d(self):
+        a = gp.array([[1.0, 2.0], [3.0, 4.0]])
+        b = gp.array([[5.0, 6.0]])
+        result = gp.concatenate([a, b], axis=0)
+        expected = np.array([[1, 2], [3, 4], [5, 6]], dtype=np.float32)
+        npt.assert_allclose(result.to_numpy(), expected, rtol=RTOL)
+        assert result.shape == (3, 2)
+
+    def test_stack_1d(self):
+        a = gp.array([1.0, 2.0, 3.0])
+        b = gp.array([4.0, 5.0, 6.0])
+        result = gp.stack([a, b])
+        expected = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.float32)
+        npt.assert_allclose(result.to_numpy(), expected, rtol=RTOL)
+        assert result.shape == (2, 3)
+
+
+class TestPower:
+    def test_pow_array(self):
+        a_np = np.array([2.0, 3.0, 4.0], dtype=np.float32)
+        b_np = np.array([2.0, 2.0, 3.0], dtype=np.float32)
+        a = gp.array(a_np)
+        b = gp.array(b_np)
+        result = (a ** b).to_numpy()
+        expected = a_np ** b_np
+        npt.assert_allclose(result, expected, rtol=RTOL)
+
+    def test_pow_scalar(self):
+        a_np = np.array([1.0, 2.0, 3.0, 4.0], dtype=np.float32)
+        a = gp.array(a_np)
+        result = (a ** 2).to_numpy()
+        expected = a_np ** 2
+        npt.assert_allclose(result, expected, rtol=RTOL)
+
+
+class TestCopy:
+    def test_copy(self):
+        a = gp.array([1.0, 2.0, 3.0])
+        b = a.copy()
+        npt.assert_allclose(b.to_numpy(), a.to_numpy(), rtol=RTOL)
+        assert b._buffer is not a._buffer
+
+    def test_copy_shape(self):
+        a = gp.array([[1.0, 2.0], [3.0, 4.0]])
+        b = a.copy()
+        assert b.shape == a.shape
+        npt.assert_allclose(b.to_numpy(), a.to_numpy(), rtol=RTOL)
+
+
+class TestRandom:
+    def test_rand_shape(self):
+        a = gp.random.rand(5)
+        assert a.shape == (5,)
+        data = a.to_numpy()
+        assert data.min() >= 0.0
+        assert data.max() < 1.0
+
+    def test_rand_2d(self):
+        a = gp.random.rand(3, 4)
+        assert a.shape == (3, 4)
+        assert a.size == 12
+
+    def test_randn_shape(self):
+        a = gp.random.randn(100)
+        assert a.shape == (100,)
+        data = a.to_numpy()
+        # randn should have mean near 0 and std near 1 for large samples
+        assert abs(data.mean()) < 0.5  # loose check
+
+    def test_randn_2d(self):
+        a = gp.random.randn(4, 5)
+        assert a.shape == (4, 5)
+        assert a.size == 20
+
+
+class TestFlatten:
+    def test_flatten_2d(self):
+        a = gp.array([[1.0, 2.0], [3.0, 4.0]])
+        b = a.flatten()
+        assert b.shape == (4,)
+        npt.assert_allclose(b.to_numpy(), np.array([1, 2, 3, 4], dtype=np.float32), rtol=RTOL)
+
+
+class TestLen:
+    def test_len_1d(self):
+        a = gp.array([1.0, 2.0, 3.0])
+        assert len(a) == 3
+
+    def test_len_2d(self):
+        a = gp.array([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]])
+        assert len(a) == 3

gpuarray-0.1.0/gpuarray/api.py

@@ -1,99 +0,0 @@
-"""NumPy-compatible module-level functions."""
-
-from __future__ import annotations
-
-from typing import Sequence
-
-import numpy as np
-
-from .core import GPUArray, _from_numpy, matmul as _matmul
-from . import shaders
-
-
-# ----- creation functions -----
-
-def array(data) -> GPUArray:
-    """Create a GPUArray from a list, nested list, or numpy array."""
-    if isinstance(data, GPUArray):
-        return data
-    arr = np.asarray(data, dtype=np.float32)
-    if arr.ndim == 0:
-        arr = arr.reshape((1,))
-    return _from_numpy(arr)
-
-
-def zeros(shape) -> GPUArray:
-    if isinstance(shape, int):
-        shape = (shape,)
-    return _from_numpy(np.zeros(shape, dtype=np.float32))
-
-
-def ones(shape) -> GPUArray:
-    if isinstance(shape, int):
-        shape = (shape,)
-    return _from_numpy(np.ones(shape, dtype=np.float32))
-
-
-def arange(start, stop=None, step=1) -> GPUArray:
-    if stop is None:
-        stop = start
-        start = 0
-    return _from_numpy(np.arange(start, stop, step, dtype=np.float32))
-
-
-def linspace(start, stop, num=50) -> GPUArray:
-    return _from_numpy(np.linspace(start, stop, num, dtype=np.float32))
-
-
-# ----- operations -----
-
-def dot(a: GPUArray, b: GPUArray):
-    return a.dot(b)
-
-
-def matmul(a: GPUArray, b: GPUArray) -> GPUArray:
-    return _matmul(a, b)
-
-
-def sum(a: GPUArray) -> float:
-    return a.sum()
-
-
-def mean(a: GPUArray) -> float:
-    return a.mean()
-
-
-def exp(a: GPUArray) -> GPUArray:
-    return a._run_unary_op(shaders.EXP_SHADER)
-
-
-def log(a: GPUArray) -> GPUArray:
-    return a._run_unary_op(shaders.LOG_SHADER)
-
-
-def sqrt(a: GPUArray) -> GPUArray:
-    return a._run_unary_op(shaders.SQRT_SHADER)
-
-
-def abs(a: GPUArray) -> GPUArray:
-    return a._run_unary_op(shaders.ABS_SHADER)
-
-
-def max(a: GPUArray) -> float:
-    return a.max()
-
-
-def min(a: GPUArray) -> float:
-    return a.min()
-
-
-def relu(a: GPUArray) -> GPUArray:
-    return a._run_unary_op(shaders.RELU_SHADER)
-
-
-def sigmoid(a: GPUArray) -> GPUArray:
-    return a._run_unary_op(shaders.SIGMOID_SHADER)
-
-
-def tanh(a: GPUArray) -> GPUArray:
-    return a._run_unary_op(shaders.TANH_SHADER)