rsarray 1.2.10__cp315-cp315-win_amd64.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (59) hide show
  1. rsarray/__init__.py +12028 -0
  2. rsarray/_core/__init__.py +213 -0
  3. rsarray/_core/_exceptions.py +83 -0
  4. rsarray/_core/_internal.py +331 -0
  5. rsarray/_core/_multiarray_tests.py +129 -0
  6. rsarray/_core/_multiarray_umath.py +121 -0
  7. rsarray/_core/_rational_tests.py +52 -0
  8. rsarray/_core/arrayprint.py +36 -0
  9. rsarray/_core/fromnumeric.py +31 -0
  10. rsarray/_core/function_base.py +84 -0
  11. rsarray/_core/multiarray.py +385 -0
  12. rsarray/_core/numeric.py +28 -0
  13. rsarray/_core/numerictypes.py +233 -0
  14. rsarray/_core/records.py +14 -0
  15. rsarray/_core/shape_base.py +23 -0
  16. rsarray/_core/strings.py +78 -0
  17. rsarray/_core/umath.py +176 -0
  18. rsarray/_dtypes.py +1229 -0
  19. rsarray/_extra.py +6621 -0
  20. rsarray/_typing.py +24 -0
  21. rsarray/array_methods.py +1224 -0
  22. rsarray/array_ops.py +1585 -0
  23. rsarray/char.py +1590 -0
  24. rsarray/exceptions.py +45 -0
  25. rsarray/fft/__init__.py +231 -0
  26. rsarray/io.py +453 -0
  27. rsarray/lib/__init__.py +102 -0
  28. rsarray/lib/_function_base_impl.py +37 -0
  29. rsarray/lib/_index_tricks_impl.py +98 -0
  30. rsarray/lib/_nanfunctions_impl.py +1637 -0
  31. rsarray/lib/_stride_tricks_impl.py +110 -0
  32. rsarray/lib/recfunctions.py +1222 -0
  33. rsarray/lib/stride_tricks.py +106 -0
  34. rsarray/linalg/__init__.py +2603 -0
  35. rsarray/linalg/_linalg.py +91 -0
  36. rsarray/linalg/_pylinalg.py +1008 -0
  37. rsarray/linalg/lapack_lite.py +13 -0
  38. rsarray/ma/__init__.py +92 -0
  39. rsarray/ma/core.py +1385 -0
  40. rsarray/ma/extras.py +711 -0
  41. rsarray/ma/mrecords.py +144 -0
  42. rsarray/math_functions.py +965 -0
  43. rsarray/matlib.py +67 -0
  44. rsarray/num_core.cp315-win_amd64.pyd +0 -0
  45. rsarray/polynomial/__init__.py +148 -0
  46. rsarray/polynomial/_npcompat.py +721 -0
  47. rsarray/polynomial/polynomial.py +1082 -0
  48. rsarray/random/__init__.py +2266 -0
  49. rsarray/random/_distributions.py +773 -0
  50. rsarray/rec.py +207 -0
  51. rsarray/statistics.py +1360 -0
  52. rsarray/strings.py +349 -0
  53. rsarray/typing/__init__.py +26 -0
  54. rsarray-1.2.10.dist-info/METADATA +280 -0
  55. rsarray-1.2.10.dist-info/RECORD +59 -0
  56. rsarray-1.2.10.dist-info/WHEEL +4 -0
  57. rsarray-1.2.10.dist-info/licenses/LICENSE +21 -0
  58. rsarray-1.2.10.dist-info/licenses/NOTICE +7 -0
  59. rsarray-1.2.10.dist-info/sboms/rsarray.cyclonedx.json +2789 -0
rsarray/_dtypes.py ADDED
@@ -0,0 +1,1229 @@
1
+ # SPDX-License-Identifier: MIT
2
+ """完整的 dtype 语义实现(解析、属性、str/repr),逐字节对齐参考实现。
3
+
4
+ DType 采用富数据模型,支持标量、结构化、子数组、标题、对齐等全部语法,
5
+ 并复刻 数组的 dtype str/repr 生成规则。
6
+ """
7
+
8
+ import builtins
9
+ import math as _math
10
+ import sys as _sys
11
+
12
+ _NATIVE = '<' if _sys.byteorder == 'little' else '>'
13
+
14
+ # name -> (kind, itemsize, alignment)
15
+ _SCALAR_INFO = {
16
+ 'bool': ('b', 1, 1),
17
+ 'int8': ('i', 1, 1), 'int16': ('i', 2, 2), 'int32': ('i', 4, 4), 'int64': ('i', 8, 8),
18
+ 'uint8': ('u', 1, 1), 'uint16': ('u', 2, 2), 'uint32': ('u', 4, 4), 'uint64': ('u', 8, 8),
19
+ 'float16': ('f', 2, 2), 'float32': ('f', 4, 4), 'float64': ('f', 8, 8),
20
+ 'complex64': ('c', 8, 4), 'complex128': ('c', 16, 8),
21
+ 'object': ('O', 8, 8),
22
+ 'datetime64': ('M', 8, 8), 'timedelta64': ('m', 8, 8),
23
+ }
24
+
25
+ # 单字符类型码(大小写敏感)
26
+ _CHARCODE = {
27
+ '?': 'bool',
28
+ 'b': 'int8', 'B': 'uint8',
29
+ 'h': 'int16', 'H': 'uint16',
30
+ 'i': 'int32', 'I': 'uint32',
31
+ 'l': 'int64', 'L': 'uint64',
32
+ 'q': 'int64', 'Q': 'uint64',
33
+ 'e': 'float16', 'f': 'float32', 'd': 'float64', 'g': 'float64',
34
+ 'F': 'complex64', 'D': 'complex128', 'G': 'complex128',
35
+ 'O': 'object',
36
+ 'p': 'int64', 'P': 'uint64',
37
+ 'M': 'datetime64', 'm': 'timedelta64',
38
+ }
39
+
40
+ # kind+size
41
+ _KINDSIZE = {
42
+ 'i1': 'int8', 'i2': 'int16', 'i4': 'int32', 'i8': 'int64',
43
+ 'u1': 'uint8', 'u2': 'uint16', 'u4': 'uint32', 'u8': 'uint64',
44
+ 'f2': 'float16', 'f4': 'float32', 'f8': 'float64',
45
+ 'c8': 'complex64', 'c16': 'complex128',
46
+ 'b1': 'bool',
47
+ }
48
+
49
+ # 独立标量类的 C 宽度别名(dtype 归一到规范名,.type 返回源类)
50
+ _WIDTH_ALIAS_TYPES = frozenset(
51
+ ('longlong', 'ulonglong', 'longdouble', 'clongdouble'))
52
+
53
+ # 全名/别名 -> 规范名
54
+ _CANON_FULL = {
55
+ 'int': 'int64', 'uint': 'uint64',
56
+ 'intp': 'int64', 'uintp': 'uint64', 'intc': 'int32', 'uintc': 'uint32',
57
+ 'long': 'int64', 'longlong': 'int64', 'ulong': 'uint64', 'ulonglong': 'uint64',
58
+ 'short': 'int16', 'ushort': 'uint16', 'byte': 'int8', 'ubyte': 'uint8',
59
+ 'float': 'float64', 'double': 'float64', 'single': 'float32',
60
+ 'half': 'float16', 'longdouble': 'float64', 'float_': 'float64',
61
+ 'complex': 'complex128', 'cdouble': 'complex128', 'cfloat': 'complex128',
62
+ 'csingle': 'complex64', 'clongdouble': 'complex128', 'complex_': 'complex128',
63
+ 'bool': 'bool', 'bool_': 'bool',
64
+ 'object': 'object', 'object_': 'object',
65
+ }
66
+
67
+
68
+ def _round_up(offset, align):
69
+ return ((offset + align - 1) // align) * align
70
+
71
+
72
+ # Hook:rsarray 包注册解析器后,DType.type 返回 rsarray 标量类(数组语义:
73
+ # np.dtype('int64').type 即 int64 标量类型)。未注册时 .type 回退 Python builtin。
74
+ _TYPE_HOOK = None
75
+
76
+
77
+ def _set_type_hook(fn):
78
+ global _TYPE_HOOK
79
+ _TYPE_HOOK = fn
80
+
81
+
82
+ class _DTypeTypeDesc:
83
+ """metaclass 级数据描述符:仅在**类访问**(DType.type)时生效,
84
+ 返回可解析的泛型字符串类型(与 np.empty(shape, dtype=DType) 的产物
85
+ dtype |S0 一致,供兼容套件 dtype 类分支做 dtype 往返与填充值构造)。
86
+ 实例访问(d.type)走类体 @property type,按 kind 分派标量类。
87
+
88
+ 必须是数据描述符(定义 __set__/__delete__):否则 metaclass 属性在
89
+ 某些解释器路径下不可靠;类体 property 已优先接管实例访问。"""
90
+
91
+ def __get__(self, inst, owner):
92
+ try:
93
+ from .__init__ import string_ as _st
94
+ return _st
95
+ except Exception:
96
+ return bytes
97
+
98
+ def __set__(self, inst, value):
99
+ raise AttributeError("can't set DType.type")
100
+
101
+ def __delete__(self, inst):
102
+ raise AttributeError("can't delete DType.type")
103
+
104
+
105
+ class _DTypeMeta(type):
106
+ type = _DTypeTypeDesc()
107
+
108
+
109
+ class DType(metaclass=_DTypeMeta):
110
+ """元素数据类型,兼容 dtype 的属性与 str/repr。
111
+
112
+ 【关于 object dtype】
113
+ ⚠️ 性能警告:object dtype 会完全失去向量化的速度优势!
114
+
115
+ 当 dtype='object' 时,数组存储的是 Python 对象的引用,而不是数值数据。
116
+ 这会导致以下性能问题:
117
+ - 无法利用 SIMD 指令加速
118
+ - 每次 Python 循环都会产生类型检查和函数调用开销
119
+ - 内存占用更高(存储对象引用 + Python 对象本身)
120
+ - 多线程性能下降(GIL 无法释放)
121
+
122
+ 【推荐替代方案】
123
+ 1. 变长字符串:使用固定长度字符串 dtype(如 'U10')
124
+ 2. 大整数:如果范围在 ±2^53 内,使用 int64
125
+ 3. 混合类型:重新设计数据结构,使用结构化数组
126
+ 4. Python 对象:考虑使用列表或字典,而不是数组
127
+
128
+ 【使用示例】
129
+ >>> import rsarray as np
130
+ >>> # 不推荐:使用 object dtype(性能低)
131
+ >>> arr = np.array([1, 'text', 3.14], dtype=object) # 性能陷阱
132
+ >>>
133
+ >>> # 推荐:使用固定类型数组
134
+ >>> int_arr = np.array([1, 2, 3]) # int64,高性能
135
+ >>> str_arr = np.array(['a', 'b', 'c']) # 自动推断为字符串
136
+ """
137
+
138
+ __slots__ = ('_kind', '_itemsize', '_byteorder', '_alignment', '_typename',
139
+ '_names', '_fields', '_aligned', '_subdtype', '_titles',
140
+ '_dt_unit', '_type_override')
141
+
142
+ # 单例缓存:np.dtype('uint64') is np.dtype('ulong')(数组语义——
143
+ # dtype 对象不可变,同类型同配置返回同一对象)
144
+ _scalar_cache = {}
145
+
146
+ @classmethod
147
+ def _cache_key(cls, src):
148
+ return (src._typename, src._itemsize, src._names,
149
+ src._subdtype[1] if src._subdtype else None,
150
+ src._byteorder)
151
+
152
+ @property
153
+ def _is_numeric(self):
154
+ # 数组语义:数值类 dtype(b/i/u/f/c)为 True,其余(S/U/V/O/M/T)False
155
+ return self._kind in ('b', 'i', 'u', 'f', 'c')
156
+
157
+ def __new__(cls, name=None, fields=None, align=False):
158
+ if isinstance(name, str) and fields is None and not align:
159
+ try:
160
+ _k = cls._cache_key(_parse_any_dtype(name, False))
161
+ except Exception:
162
+ _k = None
163
+ if _k is not None:
164
+ inst = cls._scalar_cache.get(_k)
165
+ if inst is not None:
166
+ return inst
167
+ return super().__new__(cls)
168
+
169
+ def __init__(self, name=None, fields=None, align=False):
170
+ # 向后兼容:DType('int64') / DType(<其他>) 构造标量。
171
+ # align=True:数组语义的对齐结构体(字段偏移按对齐要求填充)。
172
+ self._kind = None
173
+ self._itemsize = 0
174
+ self._byteorder = '|'
175
+ self._alignment = 1
176
+ self._typename = None
177
+ self._names = None
178
+ self._fields = None
179
+ self._aligned = False
180
+ self._subdtype = None
181
+ self._titles = None
182
+ self._dt_unit = None
183
+ self._type_override = None
184
+ # (type, descr) 形式:np.dtype((np.record, dt)) → 结构化
185
+ # dtype 的 record 标记副本(.type = record)
186
+ if (isinstance(name, tuple) and len(name) == 2
187
+ and isinstance(name[0], type)):
188
+ _tp, _dc = name
189
+ if _tp.__name__ in ('record', '_Record'):
190
+ _base = _dc if isinstance(_dc, DType) else DType(_dc)
191
+ self._copy_from(_base)
192
+ if getattr(_base, '_names', None) is not None:
193
+ try:
194
+ import rsarray as _rn_rt
195
+ self._type_override = _rn_rt._Record
196
+ except Exception:
197
+ pass
198
+ return
199
+ if name is None and fields is None:
200
+ # 数组语义:dtype(None) / dtype() 无参 → object
201
+ name = 'O'
202
+ if name is not None:
203
+ src = _parse_any_dtype(name, False)
204
+ self._copy_from(src)
205
+ else:
206
+ src = None
207
+ if align:
208
+ self._aligned = True
209
+ if self._names:
210
+ # 数组语义:对齐结构体——每个字段偏移向上取整到自身
211
+ # 对齐要求,itemsize 补齐到最大字段对齐数
212
+ _max_align = 1
213
+ _new_fields = {}
214
+ _off = 0
215
+ for _n in self._names:
216
+ _fdt = self._fields[_n][0]
217
+ _fa = max(1, getattr(_fdt, '_alignment', 1) or 1)
218
+ _max_align = max(_max_align, _fa)
219
+ _off = _round_up(_off, _fa)
220
+ _rest = tuple(self._fields[_n][2:])
221
+ _new_fields[_n] = (_fdt, _off) + _rest
222
+ _off += _fdt._itemsize
223
+ self._itemsize = _round_up(_off, _max_align)
224
+ self._fields = _new_fields
225
+ self._alignment = _max_align
226
+ if src is not None and fields is None and not align:
227
+ try:
228
+ DType._scalar_cache[DType._cache_key(src)] = self
229
+ except Exception:
230
+ pass
231
+
232
+ def _copy_from(self, o):
233
+ self._kind = o._kind
234
+ self._itemsize = o._itemsize
235
+ self._byteorder = o._byteorder
236
+ self._alignment = o._alignment
237
+ self._typename = o._typename
238
+ self._names = o._names
239
+ self._fields = o._fields
240
+ self._aligned = o._aligned
241
+ self._subdtype = o._subdtype
242
+ self._titles = o._titles
243
+ self._dt_unit = o._dt_unit
244
+ self._type_override = getattr(o, '_type_override', None)
245
+
246
+ # ---------- 属性 ----------
247
+ @property
248
+ def kind(self):
249
+ return self._kind
250
+
251
+ @property
252
+ def itemsize(self):
253
+ return self._itemsize
254
+
255
+ @property
256
+ def type(self):
257
+ """该 dtype 对应的标量类型,对齐 `dtype.type`。
258
+
259
+ rsarray 注册 hook 后返回 rsarray 标量类(数组语义;标量类仍是
260
+ builtin 子类型,`np.iscomplexobj(dtype.type(1))` 这类嗅探写法不受
261
+ 影响);未注册 hook 时回退到可调用的 Python builtin 类型。
262
+
263
+ 【使用示例】
264
+ >>> import rsarray as np
265
+ >>> np.dtype('float64').type
266
+ <class 'rsarray.float64'>
267
+ """
268
+ # _type_override:record-view 与 C 宽度别名类(longlong 等)的源类
269
+ # 标记,优先级最高(hook 按 str(dtype) 查表无法区分同规范名的实例)。
270
+ ov = getattr(self, '_type_override', None)
271
+ if ov is not None:
272
+ return ov
273
+ # 数组语义:子数组 dtype 本身是 void dtype(携带 .shape),
274
+ # .type = np.void(如 ('i4',(2,)) → void,而非 int32)
275
+ if self._subdtype is not None:
276
+ try:
277
+ import rsarray
278
+ return getattr(rsarray, 'void', bytes)
279
+ except Exception:
280
+ return bytes
281
+ # 结构化 dtype(V):record-view(np.dtype((record,spec)) / .view(recarray)
282
+ # 标记)的 .type=record;普通结构化 .type=void(数组语义)。优先于
283
+ # hook——hook 对 V 返回字符串标量类是错的。
284
+ if self._kind == 'V':
285
+ try:
286
+ import rsarray
287
+ return getattr(rsarray, 'void', bytes)
288
+ except Exception:
289
+ return bytes
290
+ if _TYPE_HOOK is not None:
291
+ try:
292
+ t = _TYPE_HOOK(self)
293
+ except Exception:
294
+ t = None
295
+ if t is not None:
296
+ return t
297
+ kind = self._kind
298
+ if kind == 'b':
299
+ return bool
300
+ if kind == 'c':
301
+ return complex
302
+ if kind == 'f':
303
+ return float
304
+ if kind in ('i', 'u'):
305
+ return int
306
+ if kind == 'O':
307
+ return object
308
+ if kind == 'S':
309
+ try:
310
+ from .__init__ import bytes_ as _bytes_t
311
+ return _bytes_t
312
+ except Exception:
313
+ return bytes
314
+ try:
315
+ from .__init__ import str_ as _str_t
316
+ return _str_t
317
+ except Exception:
318
+ return str # 'U' 与其余字符串类
319
+
320
+ @property
321
+ def alignment(self):
322
+ return self._alignment
323
+
324
+ @property
325
+ def byteorder(self):
326
+ return self._byteorder
327
+
328
+ @property
329
+ def isnative(self):
330
+ """该 dtype 是否为原生字节序,对齐 `dtype.isnative`。"""
331
+ import sys
332
+ bo = self._byteorder
333
+ if bo in ('|', '=', '@', 'n', 'native'):
334
+ return True
335
+ native = '<' if sys.byteorder == 'little' else '>'
336
+ return bo == native
337
+
338
+ def newbyteorder(self, order='S'):
339
+ """Return a new dtype with a different byte order.
340
+
341
+ Parameters
342
+ ----------
343
+ order : str, optional
344
+ Byte order to force. One of 'S', '<', '>', '=', '|',
345
+ 'native', 'I', 'L', 'B'. Defaults to swapping the current
346
+ byte order ('S').
347
+ """
348
+ if order == 'S' or order == 'native':
349
+ # Swap byte order(数组语义:native 返回对侧字节序)
350
+ if self._byteorder == '<':
351
+ new_order = '>'
352
+ elif self._byteorder == '>':
353
+ new_order = '<'
354
+ elif self._byteorder in ('|', '=', '@', 'native', 'n', None):
355
+ import sys as _sys_bo
356
+ new_order = '>' if _sys_bo.byteorder == 'little' else '<'
357
+ else:
358
+ new_order = self._byteorder
359
+ elif order in ('<', '>', '|', '=', 'I', 'L', 'B', 'n'):
360
+ new_order = order
361
+ else:
362
+ raise ValueError(f"Invalid byte order: {order!r}")
363
+ new_dtype = DType()
364
+ new_dtype._copy_from(self)
365
+ new_dtype._byteorder = new_order
366
+ return new_dtype
367
+
368
+ @property
369
+ def names(self):
370
+ return self._names
371
+
372
+ @names.setter
373
+ def names(self, value):
374
+ # 数组语义:dt.names = ('k', 'v') 重命名字段(给定的名字依次
375
+ # 对应现有字段;超出给定数的字段被隐藏——align=True 的填充字段
376
+ # 即由此剔除)。
377
+ new_names = tuple(value)
378
+ if len(new_names) > len(self._names):
379
+ raise ValueError(
380
+ f"there are already {len(self._names)} fields, "
381
+ f"cannot set {len(new_names)} names")
382
+ old_names = list(self._names)
383
+ new_fields = {}
384
+ for i, nn in enumerate(new_names):
385
+ new_fields[nn] = self._fields[old_names[i]]
386
+ self._names = new_names
387
+ self._fields = new_fields
388
+
389
+ @property
390
+ def isalignedstruct(self):
391
+ return bool(self._aligned)
392
+
393
+ @property
394
+ def subdtype(self):
395
+ return self._subdtype
396
+
397
+ @property
398
+ def shape(self):
399
+ if self._subdtype is not None:
400
+ return self._subdtype[1]
401
+ return ()
402
+
403
+ @property
404
+ def base(self):
405
+ if self._subdtype is not None:
406
+ return self._subdtype[0]
407
+ return self
408
+
409
+ @property
410
+ def fields(self):
411
+ if self._names is None:
412
+ return None
413
+ # 字典推导代替显式 for 循环
414
+ out = {n: self._fields[n] for n in self._names}
415
+ # 二次字典推导:补全带标题的字段
416
+ out.update({
417
+ self._fields[n][2]: self._fields[n]
418
+ for n in self._names
419
+ if len(self._fields[n]) > 2 and self._fields[n][2] is not None
420
+ })
421
+ return out
422
+
423
+ @property
424
+ def str(self):
425
+ return _typestr(self)
426
+
427
+ @property
428
+ def name(self):
429
+ if self._names is not None:
430
+ return 'void%d' % self._itemsize
431
+ if self._subdtype is not None:
432
+ return 'void%d' % self._itemsize
433
+ if self._kind == 'S':
434
+ # 2.x 语义:固定长字节串 name 为 str{itemsize}
435
+ return 'str%d' % self._itemsize
436
+ if self._kind == 'U':
437
+ return 'str%d' % self._itemsize
438
+ if self._kind == 'V':
439
+ return 'void%d' % self._itemsize
440
+ return self._typename
441
+
442
+ @property
443
+ def char(self):
444
+ """单字符类型码(dtype.char 兼容)。"""
445
+ mapping = {
446
+ 'bool': '?', 'bool_': '?',
447
+ 'int8': 'b', 'int16': 'h', 'int32': 'i', 'int64': 'l',
448
+ 'uint8': 'B', 'uint16': 'H', 'uint32': 'I', 'uint64': 'L',
449
+ 'float16': 'e', 'float32': 'f', 'float64': 'd', 'float128': 'g',
450
+ 'complex64': 'F', 'complex128': 'D',
451
+ }
452
+ n = self.name
453
+ if n in mapping:
454
+ return mapping[n]
455
+ kind = self._kind
456
+ if kind in ('b', 'i', 'u', 'f', 'c', 'S', 'U', 'V', 'O', 'M', 'm'):
457
+ return kind
458
+ if n:
459
+ return n[0]
460
+ return '?'
461
+
462
+ @property
463
+ def descr(self):
464
+ if self._names is not None:
465
+ # 抽取字段描述逻辑为闭包,便于列表推导复用
466
+ def _field_descr(n):
467
+ fdt = self._fields[n][0]
468
+ if fdt._subdtype is not None:
469
+ b, sh = fdt._subdtype
470
+ return (n, _typestr(b), sh)
471
+ elif fdt._names is not None:
472
+ # 数组语义:嵌套结构化字段的 descr 全量保留子字段
473
+ return (n, fdt.descr)
474
+ else:
475
+ return (n, _typestr(fdt))
476
+ # 使用列表推导代替显式 for 循环
477
+ out = [_field_descr(n) for n in self._names]
478
+ # 数组语义:字段偏移乱序(字段选择重排)时 descr 无定义
479
+ _offs = [self._fields[n][1] for n in self._names]
480
+ if any(_offs[i] > _offs[i + 1] for i in range(len(_offs) - 1)):
481
+ raise ValueError(
482
+ "dtype.descr is not defined for types with overlapping "
483
+ "or out-of-order fields")
484
+ # 数组语义:字段选择后的尾部未用字节以 V 填充表达
485
+ try:
486
+ _total = self._itemsize
487
+ _last_n = self._names[-1]
488
+ _used = _offs[-1] + self._fields[_last_n][0]._itemsize
489
+ if _used < _total:
490
+ out.append(('', '|V%d' % (_total - _used)))
491
+ except Exception:
492
+ pass
493
+ return out
494
+ return [('', _typestr(self))]
495
+
496
+ @property
497
+ def hasobject(self):
498
+ return _has_object(self)
499
+
500
+ # ---------- 索引 ----------
501
+ def __getitem__(self, key):
502
+ if self._names is None:
503
+ raise KeyError(key)
504
+ if isinstance(key, str):
505
+ return self._fields[key][0]
506
+ if isinstance(key, int):
507
+ return self._fields[self._names[key]][0]
508
+ if isinstance(key, list):
509
+ # 一次性取出所有字段的 (v0, v1, v2) 三元组,避免重复索引
510
+ vs = [self._fields[k] for k in key]
511
+ new_names = list(key)
512
+ new_formats = [v[0] for v in vs]
513
+ new_offsets = [v[1] for v in vs]
514
+ new_titles = [v[2] if len(v) > 2 else None for v in vs]
515
+ return _build_struct(new_names, new_formats, new_offsets,
516
+ self._itemsize, new_titles, self._aligned)
517
+ raise KeyError(key)
518
+
519
+ def __len__(self):
520
+ if self._names is None:
521
+ raise TypeError("len() of unsized object")
522
+ return len(self._names)
523
+
524
+ # ---------- str / repr ----------
525
+ def __str__(self):
526
+ if self._names is not None:
527
+ return _struct_str(self, True)
528
+ if self._subdtype is not None:
529
+ return _subarray_str(self)
530
+ return _scalar_str(self)
531
+
532
+ def __repr__(self):
533
+ if self._names is not None:
534
+ arg = _struct_str(self, False)
535
+ if self._aligned:
536
+ arg += ", align=True"
537
+ return "dtype(%s)" % arg
538
+ if self._subdtype is not None:
539
+ return "dtype(%s)" % _subarray_str(self)
540
+ return "dtype(%s)" % _scalar_repr_arg(self)
541
+
542
+ # ---------- 相等 / hash ----------
543
+ def _eqkey(self):
544
+ if self._names is not None:
545
+ fk = tuple((n, self._fields[n][0]._eqkey(), self._fields[n][1])
546
+ for n in self._names)
547
+ return ('struct', fk, self._itemsize, self._aligned)
548
+ if self._subdtype is not None:
549
+ return ('sub', self._subdtype[0]._eqkey(), self._subdtype[1])
550
+ # _typename 参与等值:区分 M8[Y] vs M8[D] 等同 itemsize 的 datetime 单位
551
+ return ('scalar', self._kind, self._itemsize, _norm_bo(self),
552
+ self._typename)
553
+
554
+ def __eq__(self, other):
555
+ if isinstance(other, DType):
556
+ return self._eqkey() == other._eqkey()
557
+ if other is None:
558
+ return False
559
+ if isinstance(other, type):
560
+ # dtype 对象 == 标量类(数组语义:np.dtype('f4') == np.float32)
561
+ _nm = getattr(other, '__name__', None)
562
+ if _nm:
563
+ try:
564
+ return self._eqkey() == dtype(_nm)._eqkey()
565
+ except Exception:
566
+ return NotImplemented
567
+ return NotImplemented
568
+ # np.dtypes 命名空间的动态 dtype 类实例(ObjectDType/Float64DType/…,
569
+ # 仅带 _dt_name 属性的裸类):按 dtype 名称比较(数组语义:
570
+ # np.dtype('O') == np.dtypes.ObjectDType())
571
+ _onm = getattr(other, '_dt_name', None)
572
+ if _onm is not None:
573
+ try:
574
+ return self._eqkey() == dtype(_onm)._eqkey()
575
+ except Exception:
576
+ return NotImplemented
577
+ try:
578
+ return self._eqkey() == dtype(other)._eqkey()
579
+ except Exception:
580
+ return NotImplemented
581
+
582
+ def __ne__(self, other):
583
+ r = self.__eq__(other)
584
+ if r is NotImplemented:
585
+ return r
586
+ return not r
587
+
588
+ def __hash__(self):
589
+ return hash(self._eqkey())
590
+
591
+
592
+ # ---------- 构造工厂 ----------
593
+ def _new():
594
+ d = DType.__new__(DType)
595
+ d._kind = None
596
+ d._itemsize = 0
597
+ d._byteorder = '|'
598
+ d._alignment = 1
599
+ d._typename = None
600
+ d._names = None
601
+ d._fields = None
602
+ d._aligned = False
603
+ d._subdtype = None
604
+ d._titles = None
605
+ d._dt_unit = None
606
+ return d
607
+
608
+
609
+ def _clone_with_byteorder(dt, bo):
610
+ """克隆新 DType 实例并设 byteorder(不走单例缓存)。
611
+
612
+ DType 标量实例按 (typename, itemsize, names, subdtype, byteorder)
613
+ 缓存为单例;直接改单例的 _byteorder 会污染同类型的所有数组
614
+ (后续同 dtype 构造会把 byteorder 重置回 native)。凡需给数组挂
615
+ 非 native byteorder 的 _dtype_obj,必须用本助手克隆新实例。
616
+ """
617
+ d = _new()
618
+ d._copy_from(dt)
619
+ d._byteorder = bo
620
+ return d
621
+
622
+
623
+ def _width_alias_dtype(dt, name):
624
+ """C 宽度别名名(longlong 等)→ 带 _type_override 源类标记的 dtype 克隆。
625
+
626
+ 数组语义:dtype('longlong').type 是独立的 longlong 标量类(dtype
627
+ 本身仍是规范 8 字节整型)。必须克隆——直接改单例会污染同规范名
628
+ 的其他 dtype 实例。rsarray 尚未完成初始化(模块导入早期)时优雅
629
+ 回退为无标记 dtype。
630
+ """
631
+ try:
632
+ import rsarray
633
+ cls = getattr(rsarray, name)
634
+ except Exception:
635
+ return dt
636
+ d = _clone_with_byteorder(dt, getattr(dt, '_byteorder', None) or '=')
637
+ d._type_override = cls
638
+ return d
639
+
640
+
641
+ def _make_scalar(name, bo):
642
+ kind, itemsize, align = _SCALAR_INFO[name]
643
+ if itemsize == 1 or kind == 'O':
644
+ byteorder = '|'
645
+ elif bo == '>':
646
+ byteorder = '>'
647
+ else:
648
+ byteorder = '='
649
+ d = _new()
650
+ d._kind = kind
651
+ d._itemsize = itemsize
652
+ d._byteorder = byteorder
653
+ d._alignment = align
654
+ d._typename = name
655
+ return d
656
+
657
+
658
+ def _make_flexible(kind, width, bo):
659
+ d = _new()
660
+ d._kind = kind
661
+ if kind == 'U':
662
+ d._itemsize = width * 4
663
+ d._alignment = 4
664
+ d._byteorder = '>' if bo == '>' else '='
665
+ elif kind == 'T':
666
+ # 2.x StringDType(变长字符串):itemsize 恒 1,无宽度
667
+ d._itemsize = 1
668
+ d._alignment = 1
669
+ d._byteorder = '|'
670
+ else: # S / V
671
+ d._itemsize = width
672
+ d._alignment = 1
673
+ d._byteorder = '|'
674
+ return d
675
+
676
+
677
+ def _make_datetime(kind, unit, bo):
678
+ """datetime64(M)/timedelta64(m) 伪 dtype:itemsize 8,单位存 _dt_unit。"""
679
+ if kind == 'm':
680
+ # rsarray 的 timedelta 仅支持 generic 单位(数组语义:按单位
681
+ # 求值已弃用)
682
+ import warnings as _w
683
+ _w.warn("The 'generic' unit for rsarray timedelta is deprecated",
684
+ DeprecationWarning, stacklevel=2)
685
+ d = _new()
686
+ d._kind = kind
687
+ d._itemsize = 8
688
+ d._alignment = 8
689
+ # datetime 始终 native('='),仅允许显式大端
690
+ d._byteorder = '>' if bo == '>' else '='
691
+ d._typename = '%s8[%s]' % (kind, unit)
692
+ d._dt_unit = unit
693
+ return d
694
+
695
+
696
+ def _make_subarray(base, shape):
697
+ # 使用 math.prod 代替显式循环求积
698
+ prod = _math.prod(shape) if shape else 1
699
+ d = _new()
700
+ d._kind = 'V'
701
+ d._itemsize = base._itemsize * prod
702
+ d._byteorder = '|'
703
+ d._alignment = base._alignment
704
+ d._subdtype = (base, tuple(shape))
705
+ return d
706
+
707
+
708
+ def _layout_fields(formats, align):
709
+ offset = 0
710
+ offsets = []
711
+ max_align = 1
712
+ for f in formats:
713
+ a = f._alignment if align else 1
714
+ offset = _round_up(offset, a)
715
+ offsets.append(offset)
716
+ offset += f._itemsize
717
+ if a > max_align:
718
+ max_align = a
719
+ if align:
720
+ itemsize = _round_up(offset, max_align)
721
+ else:
722
+ itemsize = offset
723
+ return offsets, itemsize
724
+
725
+
726
+ def _build_struct(names, formats, offsets, itemsize, titles, aligned):
727
+ names = list(names)
728
+ formats = list(formats)
729
+ if titles is None:
730
+ titles = [None] * len(names)
731
+ else:
732
+ titles = list(titles)
733
+ if offsets is None:
734
+ offsets, computed = _layout_fields(formats, aligned)
735
+ else:
736
+ offsets = list(offsets)
737
+ computed = max((o + f._itemsize for o, f in zip(offsets, formats)), default=0)
738
+ if itemsize is None:
739
+ itemsize = computed
740
+ # 字典推导代替显式 for 循环
741
+ fields = {
742
+ name: ((fdt, off, title) if title is not None else (fdt, off))
743
+ for name, fdt, off, title in zip(names, formats, offsets, titles)
744
+ }
745
+ d = _new()
746
+ d._kind = 'V'
747
+ d._itemsize = itemsize
748
+ d._byteorder = '|'
749
+ d._alignment = max((f._alignment for f in formats), default=1)
750
+ d._names = tuple(names)
751
+ d._fields = fields
752
+ d._aligned = bool(aligned)
753
+ d._titles = titles
754
+ return d
755
+
756
+
757
+ # ---------- 解析 ----------
758
+ def _split_top_commas(s):
759
+ parts = []
760
+ depth = 0
761
+ cur = []
762
+ for ch in s:
763
+ if ch in '([{':
764
+ depth += 1
765
+ cur.append(ch)
766
+ elif ch in ')]}':
767
+ depth -= 1
768
+ cur.append(ch)
769
+ elif ch == ',' and depth == 0:
770
+ parts.append(''.join(cur))
771
+ cur = []
772
+ else:
773
+ cur.append(ch)
774
+ parts.append(''.join(cur))
775
+ return parts
776
+
777
+
778
+ def _parse_shape(s):
779
+ s = s.strip()
780
+ if not s:
781
+ return ()
782
+ parts = [p.strip() for p in s.split(',') if p.strip() != '']
783
+ return tuple(int(p) for p in parts)
784
+
785
+
786
+ def _parse_scalar_token(s):
787
+ s = s.strip()
788
+ orig = s
789
+ bo = None
790
+ if s and s[0] in '<>=|':
791
+ bo = s[0]
792
+ s = s[1:]
793
+ # void 前缀名('void'/'void3'/'void0')须先于 flexible 字母分支处理:
794
+ # 否则 'v3' 会把 V 当 flexible 字母解析成 float64。
795
+ if s.lower().startswith('void'):
796
+ rest = s[4:]
797
+ if rest == '' or rest.isdigit():
798
+ return _make_flexible('V', int(rest) if rest else 0, bo)
799
+ # 2.x StringDType:'T'(变长字符串,无宽度;'T<N>' 非 记法)
800
+ if s == 'T':
801
+ return _make_flexible('T', 0, bo)
802
+ # flexible with width: S3, U10, V3, a3, or bare S/U/V/a
803
+ if s and s[0] in 'SUVa':
804
+ rest = s[1:]
805
+ if rest == '' or rest.isdigit():
806
+ k = 'S' if s[0] == 'a' else s[0]
807
+ width = int(rest) if rest else 0
808
+ # 数组语义:S/U itemsize 不得超 intc max(超 → TypeError
809
+ # "data type ... not understood";void 不受此限)
810
+ if k in ('S', 'U') and \
811
+ width * (4 if k == 'U' else 1) > 2147483647:
812
+ raise TypeError("data type %r not understood" % s)
813
+ return _make_flexible(k, width, bo)
814
+ if len(s) == 1 and s in _CHARCODE:
815
+ return _make_scalar(_CHARCODE[s], bo)
816
+ # datetime64/timedelta64 伪类型:M8[unit] / m8[unit](itemsize 8,
817
+ # 不参与实际数值构造,仅供 dtype 解析/提升/比较)。
818
+ if (len(s) > 4 and s[1] == '8' and s[2] == '[' and s[-1] == ']'
819
+ and s[0] in 'Mm' and s[3:-1].isalpha()):
820
+ return _make_datetime(s[0], s[3:-1], bo)
821
+ low = s.lower()
822
+ if s in _KINDSIZE:
823
+ return _make_scalar(_KINDSIZE[s], bo)
824
+ if low in _KINDSIZE:
825
+ return _make_scalar(_KINDSIZE[low], bo)
826
+ if low in _SCALAR_INFO:
827
+ return _make_scalar(low, bo)
828
+ if low in _CANON_FULL:
829
+ dt = _make_scalar(_CANON_FULL[low], bo)
830
+ # C 宽度别名:dtype 归一到规范 dtype,.type 返回独立别名类
831
+ if orig in _WIDTH_ALIAS_TYPES:
832
+ dt = _width_alias_dtype(dt, orig)
833
+ return dt
834
+ # 规范化名 str<N>/bytes<N>:历史实现写 N=itemsize,规范为 N=itemsize*8
835
+ # (str4=U1、bytes3=S3 两种约定都要能往返,故双约定接受)。
836
+ if low.startswith('str') and low[3:].isdigit():
837
+ n = int(low[3:])
838
+ if n % 32 == 0:
839
+ return _make_flexible('U', n // 32, bo)
840
+ if n % 4 == 0:
841
+ return _make_flexible('U', n // 4, bo)
842
+ if low.startswith('bytes') and low[5:].isdigit():
843
+ n = int(low[5:])
844
+ if n % 8 == 0:
845
+ return _make_flexible('S', n // 8, bo)
846
+ return _make_flexible('S', n, bo)
847
+ if low in ('str', 'str_', 'unicode', 'unicode_'):
848
+ return _make_flexible('U', 0, bo)
849
+ if low in ('bytes', 'bytes_', 'string', 'string_'):
850
+ return _make_flexible('S', 0, bo)
851
+ if low in ('void', 'void_'):
852
+ return _make_flexible('V', 0, bo)
853
+ # void<N>(DType.name 对 V 类型的输出,N=itemsize)
854
+ if low.startswith('void') and low[4:].isdigit():
855
+ return _make_flexible('V', int(low[4:]), bo)
856
+ raise TypeError("data type %r not understood" % s)
857
+
858
+
859
+ def _parse_field_type(tok):
860
+ tok = tok.strip()
861
+ if not tok:
862
+ raise TypeError("empty dtype token")
863
+ # 剥离字节序前缀(<, >, =, |)再检测子数组形式(leading-digit / 括号),
864
+ # 否则 '<0i4' 这类"前缀+子数组计数"会漏检落到 _parse_scalar_token 报错。
865
+ # base 还原前缀以保留字节序。
866
+ _bo = ''
867
+ if tok[0] in '<>=|':
868
+ _bo = tok[0]
869
+ tok = tok[1:]
870
+ if tok[0] == '(':
871
+ depth = 0
872
+ end = 0
873
+ for i, ch in enumerate(tok):
874
+ if ch == '(':
875
+ depth += 1
876
+ elif ch == ')':
877
+ depth -= 1
878
+ if depth == 0:
879
+ end = i
880
+ break
881
+ shape = _parse_shape(tok[1:end])
882
+ rest = tok[end + 1:].strip()
883
+ base = _parse_scalar_token(_bo + rest)
884
+ return _make_subarray(base, shape)
885
+ j = 0
886
+ while j < len(tok) and tok[j].isdigit():
887
+ j += 1
888
+ if 0 < j < len(tok):
889
+ cnt = int(tok[:j])
890
+ base = _parse_scalar_token(_bo + tok[j:].strip())
891
+ return _make_subarray(base, (cnt,))
892
+ return _parse_scalar_token(_bo + tok)
893
+
894
+
895
+ def _parse_string_dtype(s, align):
896
+ parts = _split_top_commas(s)
897
+ if len(parts) == 1:
898
+ return _parse_field_type(parts[0].strip())
899
+ formats = [_parse_field_type(p.strip()) for p in parts]
900
+ names = ['f%d' % i for i in range(len(formats))]
901
+ return _build_struct(names, formats, None, None, None, align)
902
+
903
+
904
+ def _parse_list_dtype(lst, align):
905
+ # 列表推导:一次提取 (name, fdt, title) 三元组
906
+ def _parse_item(item):
907
+ name_spec = item[0]
908
+ typ = item[1]
909
+ shape = item[2] if len(item) > 2 else None
910
+ if isinstance(name_spec, (tuple, list)):
911
+ title, name = name_spec[0], name_spec[1]
912
+ else:
913
+ name, title = name_spec, None
914
+ fdt = _parse_any_dtype(typ, align)
915
+ if shape is not None and shape != ():
916
+ sh = (shape,) if isinstance(shape, int) else tuple(shape)
917
+ fdt = _make_subarray(fdt, sh)
918
+ return name, fdt, title
919
+
920
+ parsed = [_parse_item(item) for item in lst]
921
+ names = [p[0] for p in parsed]
922
+ formats = [p[1] for p in parsed]
923
+ titles = [p[2] for p in parsed]
924
+ return _build_struct(names, formats, None, None, titles, align)
925
+
926
+
927
+ def _parse_tuple_dtype(obj, align):
928
+ base = _parse_any_dtype(obj[0], align)
929
+ shp = obj[1]
930
+ # legacy 嵌套形式 (base, dtype字符串)(如 ('i8', 'i4,i4')):外层 base
931
+ # 决定存储类型(数组语义),字符串不可当子数组 shape 拆字符。
932
+ if isinstance(shp, str):
933
+ return base
934
+ # legacy 形式:S/U 柔性 dtype 的 (type, int) = (type, 字符数)
935
+ # (np.dtype(('S', 5)) → S5、('U', 4) → U4);负数或 itemsize 超 intc
936
+ # max → ValueError "invalid itemsize in generic type tuple"。其余类型
937
+ # 的 int 第二项仍按子数组 shape 处理。
938
+ if isinstance(shp, int) and not isinstance(shp, bool) and \
939
+ getattr(base, '_kind', None) in ('S', 'U'):
940
+ _bk = base._kind
941
+ if shp < 0 or shp * (4 if _bk == 'U' else 1) > 2147483647:
942
+ raise ValueError("invalid itemsize in generic type tuple")
943
+ return _make_flexible(_bk, shp, getattr(base, '_byteorder', None))
944
+ shape = (shp,) if isinstance(shp, int) else tuple(shp)
945
+ return _make_subarray(base, shape)
946
+
947
+
948
+ def _parse_dict_dtype(d, align):
949
+ if 'names' in d and 'formats' in d:
950
+ names = list(d['names'])
951
+ formats = [_parse_any_dtype(f, align) for f in d['formats']]
952
+ offsets = d.get('offsets', None)
953
+ itemsize = d.get('itemsize', None)
954
+ titles = d.get('titles', None)
955
+ aligned = align or bool(d.get('aligned', False))
956
+ return _build_struct(names, formats, offsets, itemsize, titles, aligned)
957
+
958
+ # 字典推导:一次提取 (name, typ, offset, title) 四元组
959
+ def _parse_dict_item(name, spec):
960
+ typ = spec[0]
961
+ offset = spec[1]
962
+ title = spec[2] if len(spec) > 2 else None
963
+ return name, _parse_any_dtype(typ, align), offset, title
964
+
965
+ parsed = [_parse_dict_item(name, spec) for name, spec in d.items()]
966
+ names = [p[0] for p in parsed]
967
+ formats = [p[1] for p in parsed]
968
+ offsets = [p[2] for p in parsed]
969
+ titles = [p[3] for p in parsed]
970
+ return _build_struct(names, formats, offsets, None, titles, align)
971
+
972
+
973
+ def _resolve_scalar_obj(obj):
974
+ if obj is int:
975
+ return _make_scalar('int64', None)
976
+ if obj is float:
977
+ return _make_scalar('float64', None)
978
+ if obj is complex:
979
+ return _make_scalar('complex128', None)
980
+ if obj is bool:
981
+ return _make_scalar('bool', None)
982
+ if obj is bytes:
983
+ return _make_flexible('S', 0, None)
984
+ if obj is str:
985
+ return _make_flexible('U', 0, None)
986
+ if obj is object:
987
+ return _make_scalar('object', None)
988
+ if isinstance(obj, type):
989
+ # 协议:类级 __rsarray_dtype__ 声明该类对应的 dtype(rsarray 无
990
+ # 用户自定义 C 标量注册机制,测试标量类用它声明近似 dtype)。
991
+ _rdt = getattr(obj, '__rsarray_dtype__', None)
992
+ if _rdt is not None:
993
+ return _parse_any_dtype(_rdt, False)
994
+ name = getattr(obj, '__name__', None)
995
+ if name is None:
996
+ name = getattr(obj, 'name', None)
997
+ if name is None:
998
+ name = str(obj)
999
+ return _parse_scalar_token(name)
1000
+
1001
+
1002
+ def _parse_any_dtype(obj, align):
1003
+ if isinstance(obj, DType):
1004
+ return obj
1005
+ # ndarray 输入:np.dtype(arr) = arr.dtype(数组语义)
1006
+ if not isinstance(obj, (str, bytes, type, list, tuple, dict)) \
1007
+ and hasattr(obj, '_array'):
1008
+ return dtype(obj.dtype, align)
1009
+ if isinstance(obj, str):
1010
+ return _parse_string_dtype(obj.strip(), align)
1011
+ if isinstance(obj, list):
1012
+ return _parse_list_dtype(obj, align)
1013
+ if isinstance(obj, tuple):
1014
+ return _parse_tuple_dtype(obj, align)
1015
+ if isinstance(obj, dict):
1016
+ return _parse_dict_dtype(obj, align)
1017
+ if obj is None:
1018
+ # 数组语义:dtype(None) = object dtype
1019
+ return _make_scalar('object', None)
1020
+ # dtype-like
1021
+ if type(obj).__name__ == 'dtype' and hasattr(obj, 'names') and obj.names:
1022
+ # 兼容 结构化 dtype(罕见路径)
1023
+ return _parse_string_dtype(str(obj), align)
1024
+ return _resolve_scalar_obj(obj)
1025
+
1026
+
1027
+ def dtype(obj, align=False, copy=False):
1028
+ """创建 dtype 对象(兼容 dtype 构造语义)。"""
1029
+ if isinstance(obj, DType):
1030
+ if align and obj._names is not None and not obj._aligned:
1031
+ names = list(obj._names)
1032
+ formats = [obj._fields[n][0] for n in names]
1033
+ titles = [obj._fields[n][2] if len(obj._fields[n]) > 2 else None for n in names]
1034
+ return _build_struct(names, formats, None, None, titles, True)
1035
+ return obj
1036
+ return _parse_any_dtype(obj, align)
1037
+
1038
+
1039
+ # ---------- str/repr 辅助 ----------
1040
+ def _norm_bo(dt):
1041
+ b = dt._byteorder
1042
+ if b == '|':
1043
+ return '|'
1044
+ if b == '=':
1045
+ return _NATIVE
1046
+ return b
1047
+
1048
+
1049
+ def _is_native(dt):
1050
+ return dt._byteorder in ('|', '=') or dt._byteorder == _NATIVE
1051
+
1052
+
1053
+ def _byteorder_prefix(dt):
1054
+ b = dt._byteorder
1055
+ if b == '|':
1056
+ return ''
1057
+ if b == '=':
1058
+ return _NATIVE
1059
+ return b
1060
+
1061
+
1062
+ def _typestr(dt):
1063
+ """array-protocol typestr,如 '<i4' / '|S3' / '<U10'。"""
1064
+ if dt._byteorder == '|':
1065
+ p = '|'
1066
+ elif dt._byteorder == '=':
1067
+ p = _NATIVE
1068
+ else:
1069
+ p = dt._byteorder
1070
+ k = dt._kind
1071
+ if k == 'b':
1072
+ return p + 'b1'
1073
+ if k == 'O':
1074
+ return p + 'O'
1075
+ if k == 'S':
1076
+ return p + 'S%d' % dt._itemsize
1077
+ if k == 'U':
1078
+ return p + 'U%d' % (dt._itemsize // 4)
1079
+ if k == 'T':
1080
+ return p + 'T'
1081
+ if k == 'V':
1082
+ return p + 'V%d' % dt._itemsize
1083
+ if k in ('M', 'm'):
1084
+ # datetime64/timedelta64:typestr 含单位,如 '<M8[ns]'
1085
+ return p + (dt._typename or (k + '8'))
1086
+ return p + '%s%d' % (k, dt._itemsize)
1087
+
1088
+
1089
+ def _scalar_typestr_short(dt):
1090
+ """短类型码:'<i4' / 'i1' / 'S3' / '?' / 'O'。"""
1091
+ k = dt._kind
1092
+ if k == 'b':
1093
+ return '?'
1094
+ if k == 'O':
1095
+ return 'O'
1096
+ if k == 'T':
1097
+ return 'T'
1098
+ p = _byteorder_prefix(dt)
1099
+ if k == 'S':
1100
+ return 'S%d' % dt._itemsize
1101
+ if k == 'U':
1102
+ return '%sU%d' % (p, dt._itemsize // 4)
1103
+ if k == 'V':
1104
+ return 'V%d' % dt._itemsize
1105
+ return '%s%s%d' % (p, k, dt._itemsize)
1106
+
1107
+
1108
+ def _scalar_short_quoted(dt):
1109
+ return "'%s'" % _scalar_typestr_short(dt)
1110
+
1111
+
1112
+ def _scalar_str(dt):
1113
+ """str(dtype) 用于标量。"""
1114
+ k = dt._kind
1115
+ if k in ('S', 'U', 'V', 'T') or not _is_native(dt):
1116
+ return _typestr(dt)
1117
+ return dt.name
1118
+
1119
+
1120
+ def _scalar_repr_arg(dt):
1121
+ """repr(dtype) 内部参数(引号内)用于标量。"""
1122
+ k = dt._kind
1123
+ if k == 'b':
1124
+ return "'bool'"
1125
+ if k == 'O':
1126
+ return "'O'"
1127
+ if k == 'S':
1128
+ return "'S'" if dt._itemsize == 0 else "'S%d'" % dt._itemsize
1129
+ if k == 'U':
1130
+ p = _byteorder_prefix(dt)
1131
+ return "'%sU'" % p if dt._itemsize == 0 else "'%sU%d'" % (p, dt._itemsize // 4)
1132
+ if k == 'V':
1133
+ return "'V'" if dt._itemsize == 0 else "'V%d'" % dt._itemsize
1134
+ if k == 'T':
1135
+ return "'T'"
1136
+ if _is_native(dt):
1137
+ return "'%s'" % dt._typename
1138
+ return "'%s'" % _scalar_typestr_short(dt)
1139
+
1140
+
1141
+ def _shape_repr(shape):
1142
+ return repr(tuple(shape))
1143
+
1144
+
1145
+ def _unpack_field(v):
1146
+ if len(v) > 2:
1147
+ return v[0], v[1], v[2]
1148
+ return v[0], v[1], None
1149
+
1150
+
1151
+ def _type_repr_in_list(fdt):
1152
+ if fdt._names is not None:
1153
+ return _struct_str(fdt, True)
1154
+ if fdt._subdtype is not None:
1155
+ base, shape = fdt._subdtype
1156
+ return "%s, %s" % (_type_repr_in_list(base), _shape_repr(shape))
1157
+ return _scalar_short_quoted(fdt)
1158
+
1159
+
1160
+ def _struct_list_str(dt):
1161
+ # 列表推导代替显式 for 循环
1162
+ def _entry(name):
1163
+ fdt, _off, title = _unpack_field(dt._fields[name])
1164
+ namestr = repr((title, name)) if title is not None else repr(name)
1165
+ return "(%s, %s)" % (namestr, _type_repr_in_list(fdt))
1166
+ parts = [_entry(name) for name in dt._names]
1167
+ return "[" + ", ".join(parts) + "]"
1168
+
1169
+
1170
+ def _fmt_format_entry(fdt):
1171
+ if fdt._names is not None:
1172
+ return _struct_str(fdt, True)
1173
+ if fdt._subdtype is not None:
1174
+ base, shape = fdt._subdtype
1175
+ return "(%s, %s)" % (_fmt_format_entry(base), _shape_repr(shape))
1176
+ return _scalar_short_quoted(fdt)
1177
+
1178
+
1179
+ def _struct_dict_str(dt, include_align):
1180
+ names = dt._names
1181
+ # 一次性解包所有字段,使用列表推导代替显式 for 循环
1182
+ unpacked = [_unpack_field(dt._fields[name]) for name in names]
1183
+ fld_dtypes = [u[0] for u in unpacked]
1184
+ offsets = [u[1] for u in unpacked]
1185
+ titles = [u[2] for u in unpacked]
1186
+ ret = "{'names': [" + ", ".join(repr(n) for n in names) + "]"
1187
+ ret += ", 'formats': [" + ", ".join(_fmt_format_entry(f) for f in fld_dtypes) + "]"
1188
+ ret += ", 'offsets': [" + ", ".join("%d" % o for o in offsets) + "]"
1189
+ if builtins.any(t is not None for t in titles):
1190
+ ret += ", 'titles': [" + ", ".join(repr(t) for t in titles) + "]"
1191
+ ret += ", 'itemsize': %d" % dt._itemsize
1192
+ if include_align and dt._aligned:
1193
+ ret += ", 'aligned': True"
1194
+ ret += "}"
1195
+ return ret
1196
+
1197
+
1198
+ def _is_packed(dt):
1199
+ formats = [dt._fields[n][0] for n in dt._names]
1200
+ exp_offsets, exp_itemsize = _layout_fields(formats, dt._aligned)
1201
+ actual_offsets = [dt._fields[n][1] for n in dt._names]
1202
+ return exp_offsets == actual_offsets and exp_itemsize == dt._itemsize
1203
+
1204
+
1205
+ def _struct_str(dt, include_align):
1206
+ if not (include_align and dt._aligned) and _is_packed(dt):
1207
+ return _struct_list_str(dt)
1208
+ return _struct_dict_str(dt, include_align)
1209
+
1210
+
1211
+ def _subarray_str(dt):
1212
+ base, shape = dt._subdtype
1213
+ if base._names is not None:
1214
+ base_str = _struct_str(base, True)
1215
+ elif base._subdtype is not None:
1216
+ base_str = _subarray_str(base)
1217
+ else:
1218
+ base_str = _scalar_short_quoted(base)
1219
+ return "(%s, %s)" % (base_str, _shape_repr(shape))
1220
+
1221
+
1222
+ def _has_object(dt):
1223
+ if dt._kind == 'O':
1224
+ return True
1225
+ if dt._subdtype is not None:
1226
+ return _has_object(dt._subdtype[0])
1227
+ if dt._names is not None:
1228
+ return any(_has_object(dt._fields[n][0]) for n in dt._names)
1229
+ return False