rsnumpy 1.1.2__tar.gz → 1.1.3__tar.gz

{rsnumpy-1.1.2 → rsnumpy-1.1.3}/.gitignore

@@ -1,5 +1,6 @@
 # Rust
 target/
+_split_tool/
 wheelhouse/
 Cargo.lock
 rsnum*.whl

{rsnumpy-1.1.2 → rsnumpy-1.1.3}/Cargo.lock

@@ -2,6 +2,12 @@
 # It is not intended for manual editing.
 version = 4
 
+[[package]]
+name = "accelerate-src"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "415ed64958754dbe991900f3940677e6a7eefb4d7367afd70d642677b0c7d19d"
+
 [[package]]
 name = "adler2"
 version = "2.0.1"
@@ -25,6 +31,15 @@ version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
 
+[[package]]
+name = "blas-src"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b95e83dc868db96e69795c0213143095f03de9dd3252f205d4ac716e4076a7e0"
+dependencies = [
+ "accelerate-src",
+]
+
 [[package]]
 name = "block-buffer"
 version = "0.12.1"
@@ -140,6 +155,15 @@ dependencies = [
  "cfg-if",
 ]
 
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d85363c37faeca707aef026efa9f3b34d077bce547e48f770770625c6013679e"
+dependencies = [
+ "crossbeam-utils",
+]
+
 [[package]]
 name = "crossbeam-deque"
 version = "0.8.7"
@@ -286,6 +310,12 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
+[[package]]
+name = "hermit-abi"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
+
 [[package]]
 name = "hmac"
 version = "0.13.0"
@@ -384,7 +414,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a06de3016e9fae57a36fd14dba131fccf49f74b40b7fbdb472f96e361ec71a08"
 dependencies = [
  "autocfg",
+ "num_cpus",
+ "once_cell",
  "rawpointer",
+ "thread-tree",
 ]
 
 [[package]]
@@ -456,6 +489,16 @@ dependencies = [
  "libm",
 ]
 
+[[package]]
+name = "num_cpus"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b"
+dependencies = [
+ "hermit-abi",
+ "libc",
+]
+
 [[package]]
 name = "once_cell"
 version = "1.21.4"
@@ -656,8 +699,9 @@ dependencies = [
 
 [[package]]
 name = "rsnumpy"
-version = "1.1.2"
+version = "1.1.3"
 dependencies = [
+ "blas-src",
  "ndarray",
  "num-complex",
  "num-traits",
@@ -802,6 +846,15 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "thread-tree"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ffbd370cb847953a25954d9f63e14824a36113f8c72eecf6eccef5dc4b45d630"
+dependencies = [
+ "crossbeam-channel",
+]
+
 [[package]]
 name = "time"
 version = "0.3.53"

rsnumpy-1.1.3/Cargo.toml

@@ -0,0 +1,49 @@
+[package]
+name = "rsnumpy"
+version = "1.1.3"
+edition = "2024"
+readme = "README.md"
+
+[lib]
+name = "rsnumpy"
+crate-type = ["cdylib"]
+
+[dependencies]
+pyo3 = { version = "0.29.0", features = ["extension-module"] }
+# matrixmultiply-threading：非 BLAS 平台上让纯 Rust GEMM 内核多线程并行。
+ndarray = { version = "0.17.2", features = [
+    "rayon",
+    "serde",
+    "matrixmultiply-threading",
+] }
+rayon = "1.12.0"
+rand = "0.10.2"
+rand_distr = "0.6.0"
+num-traits = "0.2.19"
+rustfft = "6.4.1"
+zip = "8.6.0"
+num-complex = "0.4.6"
+thiserror = "2.0.0"
+
+# macOS：链接系统自带的 Accelerate 框架作为 BLAS 后端（无需额外安装），
+# matmul/dot 由 ndarray 的 blas 特性自动分派到原生高性能 GEMM。
+# 其它平台不启用 BLAS，自动回退到上面的 matrixmultiply 多线程纯 Rust 内核。
+[target.'cfg(target_os = "macos")'.dependencies]
+ndarray = { version = "0.17.2", features = ["blas"] }
+blas-src = { version = "0.10", features = ["accelerate"] }
+
+[profile.release]
+opt-level = 3
+lto = "fat"
+codegen-units = 1
+strip = "symbols"
+
+[profile.dev]
+opt-level = 0
+debug = true
+
+[lints.clippy]
+too_many_arguments = "allow"
+type_complexity = "allow"
+cast_precision_loss = "allow"
+cast_sign_loss = "allow"

{rsnumpy-1.1.2 → rsnumpy-1.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rsnumpy
-Version: 1.1.2
+Version: 1.1.3
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only

{rsnumpy-1.1.2 → rsnumpy-1.1.3}/build_wheel.sh

@@ -24,7 +24,7 @@ rm -f python/rsnumpy/__init__.py.bak
 echo "  -> python/rsnumpy/__init__.py __version__ updated to $VERSION"
 
 # ========== 检查 cargo 是否可用（maturin 构建需要） ==========
-if ! command -v cargo >/dev/null 2>&1; then
+if ! command -v cargo; then
   echo "Error: 'cargo' not found in PATH." >&2
   echo "Please install Rust and Cargo from https://rustup.rs/" >&2
   echo "After installation, run: source \$HOME/.cargo/env" >&2
@@ -38,10 +38,10 @@ if [[ -f rust-toolchain.toml ]]; then
   RUST_CHANNEL=$(grep -m1 '^channel *= *' rust-toolchain.toml | sed -E 's/.*"([^"]+)".*/\1/')
   if [[ -n "${RUST_CHANNEL:-}" ]]; then
     echo "Pinned Rust toolchain (rust-toolchain.toml): $RUST_CHANNEL"
-    if command -v rustup >/dev/null 2>&1; then
+    if command -v rustup; then
       # 幂等：已安装则为空操作；离线且缺失时失败被忽略，交由后续 clippy 步骤明确报错。
-      rustup toolchain install "$RUST_CHANNEL" >/dev/null 2>&1 || true
-      rustup component add clippy --toolchain "$RUST_CHANNEL" >/dev/null 2>&1 || true
+      rustup toolchain install "$RUST_CHANNEL" || true
+      rustup component add clippy --toolchain "$RUST_CHANNEL" || true
     else
       echo "  -> rustup not found; using the cargo/clippy already on PATH." >&2
     fi
@@ -88,15 +88,15 @@ if [[ -f "$VENV_PY" && -z "$PYTHON_EXEC_SET" ]]; then
 fi
 
 # Ensure chosen Python executable exists or is runnable
-if ! command -v "$PYTHON_EXEC" >/dev/null 2>&1 && [[ ! -x "$PYTHON_EXEC" && ! -f "$PYTHON_EXEC" ]]; then
+if ! command -v "$PYTHON_EXEC" && [[ ! -x "$PYTHON_EXEC" && ! -f "$PYTHON_EXEC" ]]; then
   echo "Error: Python executable '$PYTHON_EXEC' not found or not executable." >&2
   exit 1
 fi
 
 # Prefer a maturin on PATH, otherwise try running maturin via the chosen Python
-if command -v maturin >/dev/null 2>&1; then
+if command -v maturin; then
   MATURIN_MODE="path"
-elif "$PYTHON_EXEC" -c "import maturin" >/dev/null 2>&1; then
+elif "$PYTHON_EXEC" -c "import maturin"; then
   MATURIN_MODE="python-module"
 else
   echo "Error: maturin not found. Install it in your chosen Python (e.g. '$PYTHON_EXEC -m pip install maturin')." >&2
@@ -139,7 +139,7 @@ if [[ -n "$WHEEL" && -f "$WHEEL" ]]; then
     echo "Installing into .venv ..."
     # --no-deps：本地 wheel 已含全部绑定代码，无需重新解析依赖。
     # 优先用 uv（显式 --python 指向本 venv，避免依赖是否已 activate）；无 uv 时回退到 pip。
-    if command -v uv >/dev/null 2>&1; then
+    if command -v uv; then
       uv pip install --python "$VENV_PY" --reinstall --no-deps "$WHEEL"
     else
       "$VENV_PY" -m pip install --force-reinstall --no-deps "$WHEEL"

{rsnumpy-1.1.2 → rsnumpy-1.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "rsnumpy"
-version = "1.1.2"
+version = "1.1.3"
 requires-python = ">=3.10"
 description = "A Rust-powered NumPy-compatible array library."
 readme = "README.md"

{rsnumpy-1.1.2 → rsnumpy-1.1.3}/python/rsnumpy/__init__.py

@@ -32,7 +32,7 @@ from .random import random_module as _random_module
 from . import char as _char_module
 from . import matlib as _matlib_module
 
-__version__ = "1.1.2"
+__version__ = "1.1.3"
 
 # 捕获内建函数别名：_extra 挂载会向本模块 globals 注入同名的 numpy 函数
 # （all/any/round），会遮蔽内建函数。以下别名保证本文件内部逻辑始终使用内建实现。
@@ -2273,7 +2273,18 @@ def ix_(*args):
         >>> x = np.arange(32).reshape((8, 4))
         >>> x[np.ix_([1,5,7,2], [0,3,1,2])]
     """
-    raw = _core.ix_rs(args)
+    # Rust 层的 ix_rs 只解析 Python list/tuple，故先把 ndarray 等参数
+    # 归一化为一维下标列表；布尔序列按 numpy 语义取 True 位置的下标。
+    prepared = []
+    for a in args:
+        dtype = getattr(a, '_dtype', None)
+        seq = a.tolist() if hasattr(a, 'tolist') else list(a)
+        if dtype == 'bool' or (len(seq) > 0 and _py_all(isinstance(v, bool) for v in seq)):
+            seq = [i for i, v in enumerate(seq) if v]
+        else:
+            seq = [int(v) for v in seq]
+        prepared.append(seq)
+    raw = _core.ix_rs(tuple(prepared))
     return tuple(ndarray._wrap(r) for r in raw)
 
 

{rsnumpy-1.1.2 → rsnumpy-1.1.3}/python/rsnumpy/array_methods.py

@@ -21,7 +21,8 @@ class NdArrayMethods:
     @staticmethod
     def astype(arr, dtype):
         """将数组转换为指定的数据类型。"""
-        return _wrap_result(arr._array.astype(dtype))
+        name = dtype if isinstance(dtype, str) else getattr(dtype, "__name__", str(dtype))
+        return _wrap_result(arr._array.astype(name), dtype=name)
     
     @staticmethod
     def reshape(arr, *shape):

{rsnumpy-1.1.2 → rsnumpy-1.1.3}/python/rsnumpy/linalg/__init__.py

@@ -52,7 +52,6 @@ class linalg_module:
         """计算两个数组的点积。"""
         from ..__init__ import ndarray
         result = _core.linalg.dot(_ensure(a), _ensure(b))
-        result = _round_array(result)
         a_dtype = getattr(a, '_dtype', 'float64')
         b_dtype = getattr(b, '_dtype', 'float64')
         if a_dtype in ('float64', 'float32', 'float16') or b_dtype in ('float64', 'float32', 'float16'):
@@ -68,12 +67,24 @@ class linalg_module:
     @staticmethod
     def inner(a, b):
         """计算两个数组的内积。"""
-        return _wrap(_core.linalg.inner(_ensure(a), _ensure(b)))
+        from ..__init__ import ndarray
+        result = _core.linalg.inner(_ensure(a), _ensure(b))
+        a_dtype = getattr(a, '_dtype', 'float64')
+        b_dtype = getattr(b, '_dtype', 'float64')
+        if a_dtype in ('float64', 'float32', 'float16') or b_dtype in ('float64', 'float32', 'float16'):
+            return ndarray._wrap(result, _dtype='float64')
+        return ndarray._wrap(result, _dtype='int64')
 
     @staticmethod
     def matmul(a, b):
         """计算两个数组的矩阵乘积。"""
-        return _wrap(_core.linalg.matmul(_ensure(a), _ensure(b)))
+        from ..__init__ import ndarray
+        result = _core.linalg.matmul(_ensure(a), _ensure(b))
+        a_dtype = getattr(a, '_dtype', 'float64')
+        b_dtype = getattr(b, '_dtype', 'float64')
+        if a_dtype in ('float64', 'float32', 'float16') or b_dtype in ('float64', 'float32', 'float16'):
+            return ndarray._wrap(result, _dtype='float64')
+        return ndarray._wrap(result, _dtype='int64')
 
     @staticmethod
     def inv(a):

rsnumpy-1.1.3/src/arithmetic/mod.rs

@@ -0,0 +1,47 @@
+use crate::*;
+
+#[pyfunction]
+fn add(x1: &NdArray, x2: &NdArray) -> PyResult<NdArray> {
+    let result = broadcast_binary_op(&x1.data, &x2.data, |a, b| a + b)?;
+    Ok(NdArray { data: result })
+}
+
+#[pyfunction]
+fn subtract(x1: &NdArray, x2: &NdArray) -> PyResult<NdArray> {
+    let result = broadcast_binary_op(&x1.data, &x2.data, |a, b| a - b)?;
+    Ok(NdArray { data: result })
+}
+
+#[pyfunction]
+fn multiply(x1: &NdArray, x2: &NdArray) -> PyResult<NdArray> {
+    let result = broadcast_binary_op(&x1.data, &x2.data, |a, b| a * b)?;
+    Ok(NdArray { data: result })
+}
+
+#[pyfunction]
+fn divide(x1: &NdArray, x2: &NdArray) -> PyResult<NdArray> {
+    let result = broadcast_binary_op(&x1.data, &x2.data, |a, b| a / b)?;
+    Ok(NdArray { data: result })
+}
+
+#[pyfunction]
+fn power(x1: &NdArray, x2: &NdArray) -> PyResult<NdArray> {
+    let result = broadcast_binary_op(&x1.data, &x2.data, |a, b| a.powf(b))?;
+    Ok(NdArray { data: result })
+}
+
+#[pyfunction]
+fn mod_(x1: &NdArray, x2: &NdArray) -> PyResult<NdArray> {
+    let result = broadcast_binary_op(&x1.data, &x2.data, |a, b| a % b)?;
+    Ok(NdArray { data: result })
+}
+
+pub(crate) fn register(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_function(wrap_pyfunction!(add, m)?)?;
+    m.add_function(wrap_pyfunction!(subtract, m)?)?;
+    m.add_function(wrap_pyfunction!(multiply, m)?)?;
+    m.add_function(wrap_pyfunction!(divide, m)?)?;
+    m.add_function(wrap_pyfunction!(power, m)?)?;
+    m.add_function(wrap_pyfunction!(mod_, m)?)?;
+    Ok(())
+}

rsnumpy-1.1.3/src/bitwise/mod.rs

@@ -0,0 +1,92 @@
+use crate::*;
+
+#[pyfunction]
+fn invert(x: &NdArray) -> NdArray {
+    NdArray {
+        data: x.data.mapv(|v| if v == 0.0 { 1.0 } else { 0.0 }),
+    }
+}
+
+#[pyfunction]
+fn bitwise_and(x1: &NdArray, x2: &NdArray) -> PyResult<NdArray> {
+    let result = broadcast_binary_op(&x1.data, &x2.data, |a, b| {
+        let bits = (a as i64) & (b as i64);
+        bits as f64
+    })?;
+    Ok(NdArray { data: result })
+}
+
+#[pyfunction]
+fn bitwise_or(x1: &NdArray, x2: &NdArray) -> PyResult<NdArray> {
+    let result = broadcast_binary_op(&x1.data, &x2.data, |a, b| {
+        let bits = (a as i64) | (b as i64);
+        bits as f64
+    })?;
+    Ok(NdArray { data: result })
+}
+
+#[pyfunction]
+fn bitwise_xor(x1: &NdArray, x2: &NdArray) -> PyResult<NdArray> {
+    let result = broadcast_binary_op(&x1.data, &x2.data, |a, b| {
+        let bits = (a as i64) ^ (b as i64);
+        bits as f64
+    })?;
+    Ok(NdArray { data: result })
+}
+
+#[pyfunction]
+fn left_shift(x1: &NdArray, x2: &NdArray) -> PyResult<NdArray> {
+    let result = broadcast_binary_op(&x1.data, &x2.data, |a, b| {
+        let bits = (a as i64) << (b as i64);
+        bits as f64
+    })?;
+    Ok(NdArray { data: result })
+}
+
+#[pyfunction]
+fn right_shift(x1: &NdArray, x2: &NdArray) -> PyResult<NdArray> {
+    let result = broadcast_binary_op(&x1.data, &x2.data, |a, b| {
+        let bits = (a as i64) >> (b as i64);
+        bits as f64
+    })?;
+    Ok(NdArray { data: result })
+}
+
+#[pyfunction]
+fn bitwise_not(x: &NdArray) -> NdArray {
+    NdArray {
+        data: x.data.mapv(|v| {
+            let bits = !(v as i64);
+            bits as f64
+        }),
+    }
+}
+
+#[pyfunction]
+fn binary_repr(num: i64, width: Option<usize>) -> String {
+    let w = if let Some(w) = width {
+        w
+    } else {
+        let bits = 64 - num.abs().leading_zeros();
+        if bits == 0 { 1 } else { bits as usize }
+    };
+
+    if num >= 0 {
+        format!("{num:0w$b}")
+    } else {
+        let val = (1 << w) + num;
+        format!("{val:0w$b}")
+    }
+}
+
+pub(crate) fn register(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_function(wrap_pyfunction!(invert, m)?)?;
+    m.add_function(wrap_pyfunction!(bitwise_and, m)?)?;
+    m.add_function(wrap_pyfunction!(bitwise_or, m)?)?;
+    m.add_function(wrap_pyfunction!(bitwise_xor, m)?)?;
+    m.add_function(wrap_pyfunction!(bitwise_not, m)?)?;
+    m.add_function(wrap_pyfunction!(left_shift, m)?)?;
+    m.add_function(wrap_pyfunction!(right_shift, m)?)?;
+    m.add_function(wrap_pyfunction!(binary_repr, m)?)?;
+    Ok(())
+}