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.
- rsarray/__init__.py +12028 -0
- rsarray/_core/__init__.py +213 -0
- rsarray/_core/_exceptions.py +83 -0
- rsarray/_core/_internal.py +331 -0
- rsarray/_core/_multiarray_tests.py +129 -0
- rsarray/_core/_multiarray_umath.py +121 -0
- rsarray/_core/_rational_tests.py +52 -0
- rsarray/_core/arrayprint.py +36 -0
- rsarray/_core/fromnumeric.py +31 -0
- rsarray/_core/function_base.py +84 -0
- rsarray/_core/multiarray.py +385 -0
- rsarray/_core/numeric.py +28 -0
- rsarray/_core/numerictypes.py +233 -0
- rsarray/_core/records.py +14 -0
- rsarray/_core/shape_base.py +23 -0
- rsarray/_core/strings.py +78 -0
- rsarray/_core/umath.py +176 -0
- rsarray/_dtypes.py +1229 -0
- rsarray/_extra.py +6621 -0
- rsarray/_typing.py +24 -0
- rsarray/array_methods.py +1224 -0
- rsarray/array_ops.py +1585 -0
- rsarray/char.py +1590 -0
- rsarray/exceptions.py +45 -0
- rsarray/fft/__init__.py +231 -0
- rsarray/io.py +453 -0
- rsarray/lib/__init__.py +102 -0
- rsarray/lib/_function_base_impl.py +37 -0
- rsarray/lib/_index_tricks_impl.py +98 -0
- rsarray/lib/_nanfunctions_impl.py +1637 -0
- rsarray/lib/_stride_tricks_impl.py +110 -0
- rsarray/lib/recfunctions.py +1222 -0
- rsarray/lib/stride_tricks.py +106 -0
- rsarray/linalg/__init__.py +2603 -0
- rsarray/linalg/_linalg.py +91 -0
- rsarray/linalg/_pylinalg.py +1008 -0
- rsarray/linalg/lapack_lite.py +13 -0
- rsarray/ma/__init__.py +92 -0
- rsarray/ma/core.py +1385 -0
- rsarray/ma/extras.py +711 -0
- rsarray/ma/mrecords.py +144 -0
- rsarray/math_functions.py +965 -0
- rsarray/matlib.py +67 -0
- rsarray/num_core.cp315-win_amd64.pyd +0 -0
- rsarray/polynomial/__init__.py +148 -0
- rsarray/polynomial/_npcompat.py +721 -0
- rsarray/polynomial/polynomial.py +1082 -0
- rsarray/random/__init__.py +2266 -0
- rsarray/random/_distributions.py +773 -0
- rsarray/rec.py +207 -0
- rsarray/statistics.py +1360 -0
- rsarray/strings.py +349 -0
- rsarray/typing/__init__.py +26 -0
- rsarray-1.2.10.dist-info/METADATA +280 -0
- rsarray-1.2.10.dist-info/RECORD +59 -0
- rsarray-1.2.10.dist-info/WHEEL +4 -0
- rsarray-1.2.10.dist-info/licenses/LICENSE +21 -0
- rsarray-1.2.10.dist-info/licenses/NOTICE +7 -0
- 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
|