rsnumpy 1.2.3__tar.gz → 1.2.4__tar.gz

{rsnumpy-1.2.3 → rsnumpy-1.2.4}/.gitignore

@@ -26,7 +26,6 @@ user_rules.md
 *.swp
 *.swo
 *~
-
 # OS
 .DS_Store
 Thumbs.db
@@ -38,6 +37,7 @@ run_test2.py
 out.txt
 outfile*.npy
 runoob.npz
+WiFi_Loadpull_Audit.py
 outfile*
 skrf_copy/
 test_rf_1/

{rsnumpy-1.2.3 → rsnumpy-1.2.4}/Cargo.lock

@@ -274,9 +274,9 @@ checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "portable-atomic"
-version = "1.14.0"
+version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d20d5497ef88037a52ff98267d066e7f11fcc5e99bbfbd58a42336193aacec3"
+checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85"
 
 [[package]]
 name = "portable-atomic-util"
@@ -307,9 +307,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.29.0"
+version = "0.29.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd274650b21d4bfc26a0a47587962c1edb425f69287324355cd040c3ea66071c"
+checksum = "4688ddedf473e32662b9b067670129a8afb8c18e351482c70d62ba4a88171e8b"
 dependencies = [
  "libc",
  "once_cell",
@@ -321,18 +321,18 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.29.0"
+version = "0.29.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5e2a7d2f0d013342f295c048ad19237add5154a55b1c5a254c0ec93d4109078"
+checksum = "f41027e41b4bd03f6e60f9f417fe24a6341a6bb744edd62b6f709f2a52ea30e9"
 dependencies = [
  "target-lexicon",
 ]
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.29.0"
+version = "0.29.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca85c467da1bbc8d866eea5deff9cf29ea5f7785054a17da36e65bda9c05845b"
+checksum = "e591a95526fead067432c3b3a33fc74770b87b1e04e73671090d9c2055a2b327"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -340,9 +340,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.29.0"
+version = "0.29.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ac53762fd065daa3194dd09337a38bd793a188100fd1a9304c4ab312d901771"
+checksum = "73225868fc1cd84eef2c3c230ddb91273bf1de46aeb8a4248da76d32a0924a1c"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -352,9 +352,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.29.0"
+version = "0.29.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ca3a1557399783172dc5bf39cfca835157732532cba56b71d2292161e53b362"
+checksum = "571575aa3749fa6216757dd47d2a3e7ef360f329a40f0666a9fbd14889024952"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -432,7 +432,7 @@ dependencies = [
 
 [[package]]
 name = "rsnumpy"
-version = "1.2.3"
+version = "1.2.4"
 dependencies = [
  "blas-src",
  "ndarray",
@@ -503,18 +503,18 @@ checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
 
 [[package]]
 name = "thiserror"
-version = "2.0.19"
+version = "2.0.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09a43598840e33d5b0331f38c5e30d13bb11c11210a4b58f0d9b18a5a5eefcd9"
+checksum = "ec86235f5fcc2a73650310756d2ac5b138a5780bbbdfae3eeccec992c435ba4f"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "2.0.19"
+version = "2.0.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43cbfe0cf76104d42a574802844187e84a305e531ed54455f11fbde0f10541cd"
+checksum = "bc04cd3e1236dd4a98afca4569f2deb3f120e5422a4023be2cb683f8486292af"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -567,6 +567,6 @@ dependencies = [
 
 [[package]]
 name = "zlib-rs"
-version = "0.6.6"
+version = "0.6.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b142a20ec14a91d5bc708c1dc21b080c550113d8aa77afa29635673a65dd02c5"
+checksum = "34b31d188d9d685a4f9c7b46d6e36631b07058d2cfe190267adce54dc230bf12"

{rsnumpy-1.2.3 → rsnumpy-1.2.4}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rsnumpy"
-version = "1.2.3"
+version = "1.2.4"
 edition = "2024"
 readme = "README.md"
 
@@ -9,7 +9,7 @@ name = "rsnumpy"
 crate-type = ["cdylib"]
 
 [dependencies]
-pyo3 = { version = "0.29.0", features = ["extension-module"] }
+pyo3 = { version = "0.29.2", features = ["extension-module"] }
 # matrixmultiply-threading：非 BLAS 平台上让纯 Rust GEMM 内核多线程并行。
 ndarray = { version = "0.17.2", features = [
     "rayon",
@@ -26,7 +26,7 @@ zip = { version = "8.6.0", default-features = false, features = [
     "deflate-flate2-zlib-rs",
 ] }
 num-complex = "0.4.6"
-thiserror = "2.0.19"
+thiserror = "2.0.20"
 
 # macOS：链接系统自带的 Accelerate 框架作为 BLAS 后端（无需额外安装），
 # matmul/dot 由 ndarray 的 blas 特性自动分派到原生高性能 GEMM。

{rsnumpy-1.2.3 → rsnumpy-1.2.4}/PKG-INFO

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

{rsnumpy-1.2.3 → rsnumpy-1.2.4}/pyproject.toml

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

{rsnumpy-1.2.3 → rsnumpy-1.2.4}/python/rsnumpy/__init__.py

@@ -57,7 +57,7 @@ _sys.modules['rsnumpy'] = _current_module
 _sys.modules['rsnumpy.__init__'] = _current_module
 _current_module.__name__ = 'rsnumpy'
 
-__version__ = "1.2.3"
+__version__ = "1.2.4"
 
 # 捕获内建函数别名：_extra 挂载会向本模块 globals 注入同名的 rsnumpy 函数
 # （all/any/round），会遮蔽内建函数。以下别名保证本文件内部逻辑始终使用内建实现。
@@ -696,7 +696,10 @@ class ndarray:
 
     def __abs__(self):
         """逐元素绝对值（内建 abs() 函数）。"""
-        return _wrap_result(np.abs(self._array), self._dtype)
+        result = _wrap_result(np.abs(self._array), self._dtype)
+        if result.ndim == 0:
+            return result.item()
+        return result
 
     def __eq__(self, other):
         if getattr(self, '_dtype_obj', None) is not None and \
@@ -1330,6 +1333,22 @@ def _is_ndarray(obj):
     return hasattr(obj, '_array')
 
 
+def _is_raw_ndarray(obj):
+    """检查对象是否为底层 Rust 绑定 ndarray（builtins.ndarray，无 _array 属性）。"""
+    return (
+        hasattr(obj, 'shape')
+        and hasattr(obj, 'dtype')
+        and hasattr(obj, 'ndim')
+        and hasattr(obj, 'tolist')
+        and not hasattr(obj, '_array')
+    )
+
+
+def _is_any_ndarray(obj):
+    """检查对象是否为 rsnumpy ndarray 或底层 Rust 绑定 ndarray。"""
+    return _is_ndarray(obj) or _is_raw_ndarray(obj)
+
+
 def _wrap_result(result, dtype="float64"):
     """将原始 ndarray 结果包装到 ndarray 类中。"""
     if hasattr(result, '__class__') and result.__class__.__name__ == 'ndarray':
@@ -2391,24 +2410,40 @@ def _set_slice(arr, key, value):
     n = len(recs)
     indices = list(range(*key.indices(n))) if isinstance(key, slice) else list(range(n))
     names = dt._names
+    nf = len(names)
     if _is_ndarray(value) and getattr(value, '_dtype_obj', None) is not None:
         vrecs = _flatten_records(value._raw_data)
         for pos, i in enumerate(indices):
             src = vrecs[pos % len(vrecs)]
             recs[i] = tuple(_coerce_field_value(src[j], dt._fields[names[j]][0])
-                            for j in range(len(names)))
+                            for j in range(nf))
     elif _is_ndarray(value):
         vals = value.tolist()
         for pos, i in enumerate(indices):
             sv = vals[pos % len(vals)]
-            recs[i] = tuple(_coerce_field_value(sv, dt._fields[nm][0]) for nm in names)
-    elif isinstance(value, (list, tuple)) and len(value) == len(names):
-        rec = _coerce_record(value, dt)
-        for i in indices:
-            recs[i] = rec
+            if isinstance(sv, (list, tuple)):
+                # 2-D ndarray：每行作为一条记录，sv[j] 对应第 j 个字段
+                recs[i] = tuple(_coerce_field_value(sv[j], dt._fields[names[j]][0])
+                                for j in range(nf))
+            else:
+                # 1-D ndarray：标量广播到所有字段
+                recs[i] = tuple(_coerce_field_value(sv, dt._fields[names[j]][0])
+                                for j in range(nf))
+    elif isinstance(value, list) and value and isinstance(value[0], (list, tuple)):
+        # 记录列表：每个元素是一条记录，按位置赋值（支持广播）
+        for pos, i in enumerate(indices):
+            recs[i] = _coerce_record(value[pos % len(value)], dt)
     else:
+        # 单条记录或标量广播到所有索引
+        if isinstance(value, (list, tuple)):
+            # tuple/list 视为单条记录（符合 NumPy 约定）
+            rec = _coerce_record(value, dt)
+        else:
+            # 标量：广播到所有字段
+            rec = tuple(_coerce_field_value(value, dt._fields[names[j]][0])
+                        for j in range(nf))
         for i in indices:
-            recs[i] = tuple(_coerce_field_value(value, dt._fields[nm][0]) for nm in names)
+            recs[i] = rec
     arr._raw_data = _reshape_flat(recs, arr.shape)
 
 
@@ -3327,6 +3362,31 @@ def _flatten_data(data):
     return flat
 
 
+def _contains_ndarray(data):
+    """递归检查嵌套列表/元组中是否包含 rsnumpy ndarray 或底层 Rust 绑定 ndarray。"""
+    if _is_any_ndarray(data):
+        return True
+    if isinstance(data, (list, tuple)):
+        for x in data:
+            if _contains_ndarray(x):
+                return True
+    return False
+
+
+def _convert_ndarray_deep(data):
+    """递归将嵌套列表/元组中的 ndarray（含底层 Rust 绑定）转为 Python 原生数据（tolist）。
+
+    保持原有嵌套结构，仅替换 ndarray 节点为其 tolist() 结果。
+    """
+    if _is_any_ndarray(data):
+        return data.tolist()
+    if isinstance(data, list):
+        return [_convert_ndarray_deep(x) for x in data]
+    if isinstance(data, tuple):
+        return tuple(_convert_ndarray_deep(x) for x in data)
+    return data
+
+
 def _setitem_value(value):
     """规范化赋值右值供 Rust setitem_multi 使用：
     标量原样返回；ndarray 或嵌套列表展平为 C 序浮点列表（逐元素赋值）。
@@ -3344,7 +3404,14 @@ def _setitem_value(value):
         return value
     if isinstance(value, (list, tuple)):
         flat = _flatten_data(value)
-        if _py_any(isinstance(v, complex) for v in flat):
+        # 检查是否含复数：Python complex，或 0 维复数 ndarray 元素（如 arr[i,j,j]）
+        # 复数右值原样透传，交由 Rust coerce_value_to_nd -> parse_py_complex 保留虚部
+        has_complex = _py_any(
+            isinstance(v, complex)
+            or (hasattr(v, '_array') and getattr(v._array, 'is_complex', False))
+            for v in flat
+        )
+        if has_complex:
             return value
         return [float(v) for v in flat]
     return value
@@ -3447,6 +3514,13 @@ def array(data, dtype=None, copy=True, order='K', subok=False, ndmin=0):
     - 混合类型：使用结构化数组或 Python 列表
     """
     if dtype is None:
+        # ndarray 输入快速路径：直接沿用其 dtype，避免走回退路径产生 object dtype 警告。
+        if _is_ndarray(data):
+            arr = data.copy() if copy else data
+            if ndmin > arr.ndim:
+                new_shape = (1,) * (ndmin - arr.ndim) + arr.shape
+                arr = ndarray._wrap(arr._array.reshape(new_shape), _dtype=arr._dtype)
+            return arr
         # 数值 list/tuple 快速路径：Rust 单次完成展平 + dtype 推断 + 构造。
         if isinstance(data, (list, tuple)):
             try:
@@ -3460,6 +3534,21 @@ def array(data, dtype=None, copy=True, order='K', subok=False, ndmin=0):
                     new_shape = (1,) * (ndmin - arr.ndim) + arr.shape
                     arr = ndarray._wrap(arr._array.reshape(new_shape), _dtype=_dtype)
                 return arr
+        # build_array 不支持 ndarray 元素：递归展平嵌套列表中的 ndarray 再重试
+        if _contains_ndarray(data):
+            converted = _convert_ndarray_deep(data)
+            try:
+                raw, code = np.build_array(converted)
+            except (ValueError, TypeError):
+                raw = None
+            if raw is not None:
+                _dtype = _BUILD_ARRAY_DTYPES[code]
+                arr = ndarray._wrap(raw, _dtype=_dtype)
+                if ndmin > arr.ndim:
+                    new_shape = (1,) * (ndmin - arr.ndim) + arr.shape
+                    arr = ndarray._wrap(arr._array.reshape(new_shape), _dtype=_dtype)
+                return arr
+            data = converted
         # 回退慢路径：复数/字符串/不规则/标量
         if isinstance(data, tuple):
             data = list(data)
@@ -4867,7 +4956,7 @@ __all__ = [
     'transpose', 'swapaxes', 'expand_dims', 'squeeze',
     'concatenate', 'stack', 'vstack', 'hstack', 'dstack', 'column_stack',
     'split', 'hsplit', 'vsplit', 'dsplit',
-    'tile', 'repeat',
+    'tile', 'repeat', 'LazyArray',
     'flip', 'fliplr', 'flipud', 'roll', 'rot90',
     'append', 'insert', 'delete', 'unique', 'resize',
     'where', 'take', 'put', 'select', 'nonzero', 'argwhere', 'flatnonzero',

{rsnumpy-1.2.3 → rsnumpy-1.2.4}/src/random.rs

@@ -16,6 +16,10 @@ thread_local! {
 
 static GLOBAL_SEED: std::sync::OnceLock<u64> = std::sync::OnceLock::new();
 
+fn get_global_seed() -> u64 {
+    *GLOBAL_SEED.get_or_init(rand::random)
+}
+
 fn with_thread_rng<F, R>(f: F) -> R
 where
     F: FnOnce(&mut ::rand::rngs::StdRng) -> R,
@@ -23,7 +27,7 @@ where
     THREAD_RNG.with(|cell| {
         let mut rng = cell.borrow_mut();
         if rng.is_none() {
-            let seed = GLOBAL_SEED.get().copied().unwrap_or(0xdeadbeef);
+            let seed = get_global_seed();
             let mut hasher = std::collections::hash_map::DefaultHasher::new();
             std::thread::current().id().hash(&mut hasher);
             let thread_seed = seed.wrapping_add(hasher.finish().wrapping_mul(0x9e3779b97f4a7c15));
@@ -144,7 +148,7 @@ fn seed(val: u64) {
 
 #[pyfunction]
 fn get_state() -> u64 {
-    GLOBAL_SEED.get().copied().unwrap_or(0xdeadbeef)
+    get_global_seed()
 }
 
 #[pyfunction]
@@ -209,6 +213,7 @@ struct PyRandomState {
 #[pymethods]
 impl PyRandomState {
     #[new]
+    #[pyo3(signature = (seed=None))]
     fn new(seed: Option<u64>) -> Self {
         PyRandomState {
             rng: Mutex::new(::rand::rngs::StdRng::seed_from_u64(
@@ -348,6 +353,7 @@ impl PyGenerator {
 #[pymethods]
 impl PyGenerator {
     #[new]
+    #[pyo3(signature = (seed=None))]
     fn new(seed: Option<u64>) -> Self {
         PyGenerator {
             rng: Mutex::new(::rand::rngs::StdRng::seed_from_u64(

{rsnumpy-1.2.3 → rsnumpy-1.2.4}/test/test_rf/skrf/media/media.py

@@ -1156,6 +1156,7 @@ class Media(ABC):
         return result
 
     def delay_load(
+        
             self,
             Gamma0: NumberLike,
             d: Number,

{rsnumpy-1.2.3 → rsnumpy-1.2.4}/test/test_rf/test.py

@@ -1278,3 +1278,4 @@ Marchand_circuit.plot_s_db(m=1, n=1, lw=2)
 
 plt.ylim(-50, 10)
 ssaver('./test/test_rf/test61.png')
+print(np.random.rand(10))

{rsnumpy-1.2.3 → rsnumpy-1.2.4}/test/test_rf/test1.py

@@ -254,6 +254,5 @@ mod.name = 'Model'
 mod.plot_s_db(0, 0, color='k')
 mod.plot_s_db(1, 0, color='k')
 ssaver('./test/test_rf/test_data/test10.png')
-
 start_time = time.time()
 print(f"Time cost: {start_time - end_time} seconds")

rsnumpy-1.2.4/test/testing_rspandas2.py

@@ -0,0 +1,190 @@
+import time
+start_time = time.time()
+
+import rsnumpy as np  # noqa: E402
+from collections import namedtuple  # noqa: E402
+from dataclasses import make_dataclass  # noqa: E402
+import rspandas as pd  # noqa: E402
+
+
+def print_series(num, s):
+    print("++++++++++++++++++++", num)
+    print(s)
+    print()
+
+
+s = pd.Series(np.random.randn(5), index=["a", "b", "c", "d", "e"])
+print_series(1, s)
+print_series(2, s.index)
+print_series(3, pd.Series(np.random.randn(5)))
+d = {"b": 1, "a": 0, "c": 2}
+print_series(4, pd.Series(d))
+d = {"a": 0.0, "b": 1.0, "c": 2.0}
+print_series(5, pd.Series(d))
+print_series(6, pd.Series(d, index=["b", "c", "d", "a"]))
+print_series(7, pd.Series(5.0, index=["a", "b", "c", "d", "e"]))
+print_series(8, s.iloc[0])
+print_series(9, s.iloc[:3])
+print_series(10, s[s > s.median()])
+print_series(11, s.iloc[[4, 3, 1]])
+print_series(12, np.exp(s))
+print_series(13, s.dtype)
+print_series(14, s.array)
+print_series(15, s.to_numpy())
+print_series(16, s["a"])
+s["e"] = 12.0
+print_series(17, s)
+print_series(18, "e" in s)
+print_series(19, "f" in s)
+print_series(20, s.get("f"))
+print_series(21, s.get("f", np.nan))
+print_series(22, s + s)
+print_series(23, np.exp(s))
+print_series(24, s.iloc[1:] + s.iloc[:-1])
+s = pd.Series(np.random.randn(5), name="something")
+print_series(25, s)
+print_series(26, s.name)
+s2 = s.rename("different")
+print_series(27, s2.name)
+d = {
+    "one": pd.Series([1.0, 2.0, 3.0], index=["a", "b", "c"]),
+    "two": pd.Series([1.0, 2.0, 3.0, 4.0], index=["a", "b", "c", "d"]),
+}
+df = pd.DataFrame(d)
+print_series(28, df)
+print_series(29, pd.DataFrame(d, index=["d", "b", "a"]))
+print_series(30, pd.DataFrame(d, index=["d", "b", "a"], columns=["two", "three"]))
+print_series(31, df.index)
+print_series(32, df.columns)
+d = {"one": [1.0, 2.0, 3.0, 4.0], "two": [4.0, 3.0, 2.0, 1.0]}
+print_series(33, pd.DataFrame(d))
+print_series(34, pd.DataFrame(d, index=["a", "b", "c", "d"]))
+data = np.zeros((2,), dtype=[("A", "i4"), ("B", "f4"), ("C", "S10")])
+data[:] = [(1, 2.0, "Hello"), (2, 3.0, "World")]
+print_series(35, pd.DataFrame(data))
+print_series(36, pd.DataFrame(data, index=["first", "second"]))
+print_series(37, pd.DataFrame(data, columns=["C", "A", "B"]))
+data2 = [{"a": 1, "b": 2}, {"a": 5, "b": 10, "c": 20}]
+print_series(38, pd.DataFrame(data2))
+print_series(39, pd.DataFrame(data2, index=["first", "second"]))
+print_series(40, pd.DataFrame(data2, columns=["a", "b"]))
+print_series(41, pd.DataFrame(
+    {
+        ("a", "b"): {("A", "B"): 1, ("A", "C"): 2},
+        ("a", "a"): {("A", "C"): 3, ("A", "B"): 4},
+        ("a", "c"): {("A", "B"): 5, ("A", "C"): 6},
+        ("b", "a"): {("A", "C"): 7, ("A", "B"): 8},
+        ("b", "b"): {("A", "D"): 9, ("A", "B"): 10},
+    }
+))
+ser = pd.Series(range(3), index=list("abc"), name="ser")
+print_series(42, pd.DataFrame(ser))
+Point = namedtuple("Point", "x y")
+print_series(43, pd.DataFrame([Point(0, 0), Point(0, 3), (2, 3)]))
+Point3D = namedtuple("Point3D", "x y z")
+print_series(44, pd.DataFrame([Point3D(0, 0, 0), Point3D(0, 3, 5), Point(2, 3)]))
+Point = make_dataclass("Point", [("x", int), ("y", int)])
+print_series(45, pd.DataFrame([Point(0, 0), Point(0, 3), Point(2, 3)]))
+print_series(46, pd.DataFrame.from_dict(dict([("A", [1, 2, 3]), ("B", [4, 5, 6])])))
+print_series(47, pd.DataFrame.from_dict(
+    dict([("A", [1, 2, 3]), ("B", [4, 5, 6])]),
+    orient="index",
+    columns=["one", "two", "three"],
+))
+print_series(48, data)
+print_series(49, pd.DataFrame.from_records(data, index="C"))
+print_series(50, df["one"])
+df["three"] = df["one"] * df["two"]
+print_series(51, df)
+del df["two"]
+three = df.pop("three")
+print_series(52, df)
+df["foo"] = "bar"
+print_series(53, df)
+df["one_trunc"] = df["one"][:2]
+print_series(54, df)
+df.insert(1, "bar", df["one"])
+print_series(55, df)
+iris = pd.read_csv("./testing/data/iris.data")
+print_series(56, iris.head())
+print_series(57, iris.assign(sepal_ratio=iris["SepalWidth"] / iris["SepalLength"]).head())
+print_series(58, iris.assign(sepal_ratio=lambda x: (x["SepalWidth"] / x["SepalLength"])).head())
+print_series(59, iris.assign(sepal_ratio=pd.col("SepalWidth") / pd.col("SepalLength")).head())
+(
+    iris.query("SepalLength > 5")
+    .assign(
+        SepalRatio=lambda x: x.SepalWidth / x.SepalLength,
+        PetalRatio=lambda x: x.PetalWidth / x.PetalLength,
+    )
+    .plot(kind="scatter", x="SepalRatio", y="PetalRatio")
+)
+dfa = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
+print_series(60, dfa.assign(C=lambda x: x["A"] + x["B"], D=lambda x: x["A"] + x["C"]))
+print_series(61, df.loc["b"])
+print_series(62, df.iloc[2])
+df = pd.DataFrame(np.random.randn(10, 4), columns=["A", "B", "C", "D"])
+df2 = pd.DataFrame(np.random.randn(7, 3), columns=["A", "B", "C"])
+print_series(63, df + df2)
+print_series(64, df - df.iloc[0])
+print_series(65, df * 5 + 2)
+print_series(66, 1 / df)
+print_series(67, df ** 4)
+df1 = pd.DataFrame({"a": [1, 0, 1], "b": [0, 1, 1]}, dtype=bool)
+df2 = pd.DataFrame({"a": [0, 1, 1], "b": [1, 1, 0]}, dtype=bool)
+print_series(68, df1 & df2)
+print_series(69, df1 | df2)
+print_series(70, df1 ^ df2)
+print_series(71, -df1)
+print_series(72, df[:5].T)
+print_series(73, np.exp(df))
+print_series(74, np.asarray(df))
+ser = pd.Series([1, 2, 3, 4])
+print_series(75, np.exp(ser))
+ser1 = pd.Series([1, 2, 3], index=["a", "b", "c"])
+ser2 = pd.Series([1, 3, 5], index=["b", "a", "c"])
+print_series(76, ser1)
+print_series(77, ser2)
+print_series(78, np.remainder(ser1, ser2))
+ser3 = pd.Series([2, 4, 6], index=["b", "c", "d"])
+print_series(79, ser3)
+print_series(80, np.remainder(ser1, ser3))
+ser = pd.Series([1, 2, 3])
+print_series(81, ser)
+idx = pd.Index([4, 5, 6])
+print_series(82, np.maximum(ser, idx))
+baseball = pd.read_csv("./testing/data/baseball.csv")
+print_series(83, baseball)
+print_series(84, baseball.info())
+print_series(85, baseball.iloc[-20:, :12].to_string())
+print_series(86, pd.DataFrame(np.random.randn(3, 12)))
+pd.set_option("display.width", 40)
+print_series(87, pd.DataFrame(np.random.randn(3, 12)))
+datafile = {
+    "filename": ["filename_01", "filename_02"],
+    "path": [
+        "./testing/rspandas/filename_01",
+        "./testing/rspandas/filename_02",
+    ],
+}
+pd.set_option("display.max_colwidth", 30)
+print_series(88, pd.DataFrame(datafile))
+pd.set_option("display.max_colwidth", 100)
+print_series(89, pd.DataFrame(datafile))
+df = pd.DataFrame({"foo1": np.random.randn(5), "foo2": np.random.randn(5)})
+print_series(90, df)
+print_series(91, df.foo1)
+index = pd.date_range("1/1/2000", periods=8)
+s = pd.Series(np.random.randn(5), index=["a", "b", "c", "d", "e"])
+df = pd.DataFrame(np.random.randn(8, 3), index=index, columns=["A", "B", "C"])
+long_series = pd.Series(np.random.randn(1000))
+print_series(92, long_series.head())
+print_series(93, long_series.tail(3))
+print_series(94, df[:2])
+df.columns = [x.lower() for x in df.columns]
+print_series(95, df)
+print_series(96, s.array)
+print_series(97, s.index.array)
+print_series(98, s.to_numpy())
+print_series(99, np.asarray(s))
+end_time = time.time()
+print("end_time - start_time:", end_time - start_time)

rsnumpy-1.2.3/test/test_rf/WiFi_Loadpull_Audit.py

@@ -1,38 +0,0 @@
-import rsplotlib.pyplot as plt
-# import rsnumpy as np
-from rsplotlib import style
-
-import skrf as rf
-
-# 保存当前图
-def ssaver(name):
-    plt.savefig(name)
-    plt.clf()
-
-
-s2p = rf.Network('/Users/user/Downloads/WI-FI loadpull-APL/New cable/Audit_5G_New_cable1.s2p')
-s2p.frequency.unit = 'ghz'
-mpl_style = "seaborn-ticks"
-with style.context(mpl_style):
-    s2p.plot_s_smith(m=0, n=0, draw_labels=True)
-plt.legend()  # have to re-generate legend
-
-ssaver('./test/test_rf/test_1.png')
-
-s2p = rf.Network('/Users/user/Downloads/WI-FI loadpull-APL/New cable/Audit_5G_New_cable2.s2p')
-s2p.frequency.unit = 'ghz'
-mpl_style = "seaborn-ticks"
-with style.context(mpl_style):
-    s2p.plot_s_smith(m=0, n=0, draw_labels=True)
-plt.legend()  # have to re-generate legend
-
-ssaver('./test/test_rf/test_2.png')
-
-s2p = rf.Network('/Users/user/Downloads/WI-FI loadpull-APL/New cable/Audit_5G_Old_cable.s2p')
-s2p.frequency.unit = 'ghz'
-mpl_style = "seaborn-ticks"
-with style.context(mpl_style):
-    s2p.plot_s_smith(m=0, n=0, draw_labels=True)
-plt.legend()  # have to re-generate legend
-
-ssaver('./test/test_rf/test_3.png')