chronaxis 0.1.0.dev0__py3-none-any.whl

chronaxis/core/expression_numpy.py

@@ -0,0 +1,314 @@
+"""在同长度信号列上批量求值表达式，并逐位置保留质量诊断。
+
+evaluate_numpy接收当前编译绑定和context中的NumericArray，输出
+ArrayEvaluation：数值结果列与独立的uint16依赖诊断列均为形状(N,)。
+布尔逻辑用掩码区分TRUE、FALSE和UNKNOWN（未知），不把无效False占位
+当作条件不成立；已知值决定结果时，原依赖异常仍留在诊断列。
+
+解释器按表达式树遍历节点，每个节点用NumPy逐元素函数计算整列。
+isclose使用显式atol与rtol计算abs(a-b) <= atol + rtol*abs(b)。
+evaluate_memory_numpy从已有内存行归一化信号，用searchsorted找到每个
+查询时间的最近观测，再按有效期保持并求值，不额外读取或解码。
+
+依赖NumPy及核心编译、数值和对齐模块；共享检查协议，不调用参考数值
+求值器。结果为独立只读存储，当前批次缓存不跨调用保留，不修改输入。
+"""
+
+# 冻结输出及明确映射接口。
+from dataclasses import dataclass
+# 数组依赖显式，不污染标准库core导入。
+import numpy as np
+# 当前静态树是共享已校验协议，不共享样本数值内核。
+from .expression import CompiledExpression
+# 真实绑定参与执行身份检查。
+from .binding import SignalBindings
+# 解码运行证据与实际memory绑定共用检查协议，不共享参考数值计算。
+from .decoded_binding import DecodedBindings
+# 消息绑定只扩显式typed context，不改变普通数值核或memory时间保持入口。
+from .message_binding import MessageBindings
+# 只共享dtype常量，精确整数比较literal不转float。
+from .numeric import INTEGER_BOUNDS
+# 数组真实数值入口与布局模型。
+from .numeric_numpy import (COMPARE_UFUNCS, DTYPES, NumericArray, _output, _readonly,
+                            binary_numpy, to_float_numpy, unary_numpy)
+# 此函数只校验身份与列映射，没有参考数值运算。
+from .expression_reference import require_context
+# 原行批量适配独立于参考转换。
+from .normalize_numpy import memory_series_numpy
+# 独立NumPy保持，不调用参考对齐。
+from .state_numpy import align_numpy, build_signal_array, _require_axis
+# 基础质量及bool有效mask实施三值，不对数组bool求值。
+from .types import QualityFlag as Q, SignalDType as D
+
+
+@dataclass(frozen=True)
+class ArrayEvaluation:
+    """保存同长度的计算结果列与依赖质量诊断列。
+
+    value为NumericArray，dependency_quality是形状(N,)的uint16数组。
+    布尔结果可能因已知TRUE或FALSE而有效，诊断仍可包含非零的原依赖原因；
+    不能因此把UNKNOWN填为FALSE。构造时检查诊断布局并复制为只读存储。
+    实例不可重新赋值，不持有跨批次的求值状态。
+    """
+
+    value: NumericArray  # 真实逻辑结果列。
+    dependency_quality: np.ndarray  # 同长uint16原因并集。
+
+    def __post_init__(self):
+        """验证诊断布局和已知位后复制只读列。
+
+        参数: 无，读取value与dependency_quality。
+        返回: None，不修改调用侧数组。
+        异常: TypeError/ValueError为结构/长度/未知位。
+        """
+        # 真实typed结果需与诊断同一布局。
+        if not isinstance(self.value, NumericArray) or type(self.dependency_quality) is not np.ndarray or self.dependency_quality.ndim != 1 or self.dependency_quality.dtype != np.dtype('uint16'):
+            # 不用广播/隐式cast修正错误接口。
+            raise TypeError('ArrayEvaluation诊断需1维uint16列')
+        # 未知位不能以诊断为名通过。
+        if len(self.dependency_quality) != len(self.value.values) or np.any(self.dependency_quality > 511):
+            # 正常BOOL可带诊断，但结构仍严格。
+            raise ValueError('ArrayEvaluation诊断长度/原因不合法')
+        # 结果与诊断都具独立所有权。
+        object.__setattr__(self, 'dependency_quality', _readonly(self.dependency_quality))
+
+
+def _logic(operator, values):
+    """独立以整列掩码实现and/or/not三值真值表。
+
+    参数: operator固定逻辑名；values为同长BOOL列tuple。
+    返回: NumericArray，known决定时质量NONE，否则UNKNOWN原因并集。
+    异常: 调用者保证static BOOL及shape，分配错误传播。
+    """
+    # not不将invalid False占位当作真False。
+    if operator == 'not':
+        # 正常位置取反，valid/原因不改变。
+        result = np.zeros(len(values[0].values), dtype=bool)
+        # where避免对invalid占位作正常逻辑。
+        np.logical_not(values[0].values, out=result, where=values[0].valid)
+        # 原原因保持，不清UNKNOWN。
+        return _output(D.BOOL, result, values[0].quality.copy())
+    # 行数明确，不对数组做Python truthiness。
+    size = len(values[0].values)
+    # 默认没有known决断/没有原因。
+    decided = np.zeros(size, dtype=bool)
+    # uint16保留高位诊断。
+    quality = np.zeros(size, dtype=np.uint16)
+    # 逻辑节点的静态操作数循环，每次都真实整列mask。
+    for value in values:
+        # unknown原因先并集，decision后只清结果质量。
+        quality |= value.quality
+        # and由knownFalse决定，or由knownTrue决定。
+        decided |= value.valid & (~value.values if operator == 'and' else value.values)
+    # 已知决断给正常结果，原诊断由ArrayEvaluation另保存。
+    quality[decided] = 0
+    # and没有knownFalse且没有unknown时TRUE；or仅decided位置TRUE。
+    result = ~decided if operator == 'and' else decided
+    # unknown存储值不解释为正常bool，valid由quality决定。
+    return _output(D.BOOL, result, quality)
+
+
+def _constant(node, size):
+    """将已校验literal装箱同长typed列，不猜dtype或enum域。
+
+    参数: node为const，size为非负明确行数。
+    返回: 正常NumericArray；integer边界此前静态检查。
+    异常: 模型/分配错误传播，不自动promotion。
+    """
+    # enum固定标签域，正常code由当前域唯一确定。
+    value = node.labels.index(node.value) if node.labels else node.value
+    # 常量复制为整列，不靠广播误配输入。
+    values = np.full(size, value, dtype=DTYPES[node.dtype])
+    # literal没有上游质量异常。
+    return _output(node.dtype, values, np.zeros(size, dtype=np.uint16), node.labels)
+
+
+def _literal_compare(node, value):
+    """在整数域比较原列与任意精确Python整数常量边界。
+
+    参数: node含固定比较名/原整数边界；value为定宽整数列。
+    返回: BOOL列，invalid保持原原因，不转float或cast越界常量。
+    异常: 编译器保证类型与注册比较，分配错误传播。
+    """
+    # 边界上下限是精确Python静态配置，不是逐样本计算。
+    lower, upper = INTEGER_BOUNDS[value.dtype]
+    # 运算名来自白名单编译节点。
+    operator = node.operator[12:]
+    # 输出占位不正常使用。
+    result = np.zeros(len(value.values), dtype=bool)
+    # 太小边界：所有正常原值都大于它。
+    if node.value < lower:
+        # 不把超界常量cast成机器整数。
+        result[value.valid] = operator in ('ne', 'gt', 'ge')
+    # 太大边界：所有正常原值都小于它。
+    elif node.value > upper:
+        # 即使2**100也精确判定，不经过float。
+        result[value.valid] = operator in ('ne', 'lt', 'le')
+    else:
+        # 已证明可表示，才按相同dtype精确ufunc比较。
+        COMPARE_UFUNCS[operator](value.values, DTYPES[value.dtype].type(node.value), out=result, where=value.valid)
+    # known比较正常，unknown原因原样保持。
+    return _output(D.BOOL, result, value.quality.copy())
+
+
+def _evaluate(node, context, size, cache):
+    """按静态节点结构调用真实批量数值/逻辑内核。
+
+    参数: node冻结树；context当前同长列；size行数；cache本次batch局部缓存。
+    返回: ArrayEvaluation，完整诊断不因known逻辑结果丢失。
+    异常: 静态/输入模型问题传播，不调用reference/eval/逐样本Python。
+    """
+    # 当前batch/真实绑定局部公共子表达式复用。
+    if node in cache:
+        # 不能跨batch/会话继承数值。
+        return cache[node]
+    # 裸literal仅类型装箱，没有逐样本计算。
+    if node.operator == 'const':
+        # shape与所有信号相同。
+        value = _constant(node, size)
+        # 常量没有原依赖异常。
+        result = ArrayEvaluation(value, value.quality)
+    # Name只取当前显式context已解码列。
+    elif node.operator == 'name':
+        # 外层已校验dtype/labels/shape及真实绑定身份。
+        value = context[node.name]
+        # 原质量同步保存在诊断列。
+        result = ArrayEvaluation(value, value.quality)
+    else:
+        # 对静态子树递归，每个节点执行整列，不逐样本解释。
+        children = tuple(_evaluate(arg, context, size, cache) for arg in node.args)
+        # 真正数值输入不是diagnostic数组。
+        values = tuple(child.value for child in children)
+        # 诊断逐节点整列并集，不借normal bool清原因。
+        diagnostic = np.zeros(size, dtype=np.uint16)
+        # 此循环维度是表达式静态操作数个数。
+        for child in children:
+            # 所有求值子树的原/计算质量纳入诊断。
+            diagnostic |= child.dependency_quality
+        # 三值布尔核独立于标量参考真值表代码。
+        if node.operator in ('and', 'or', 'not'):
+            # 已知决断可normal；diagnostic仍保留UNKNOWN。
+            value = _logic(node.operator, values)
+        # 数值单目先检查定宽再ufunc。
+        elif node.operator in ('abs', 'neg'):
+            # 调用真实数组数值核，而非np.vectorize。
+            value = unary_numpy(node.operator, values[0])
+        # 显式常量float上下文仍用独立尾位精度核。
+        elif node.operator == 'to_float':
+            # 大整数不默默变近似float。
+            value = to_float_numpy(values[0])
+        # 常量大边界不能塞进定宽列后wrap。
+        elif node.operator.startswith('int_literal_'):
+            # 独立静态端点判定及正常整数ufunc。
+            value = _literal_compare(node, values[0])
+        # 显式isclose判据由安全批量数值原语实施。
+        elif node.operator == 'isclose':
+            # 四个实参各自先检查整数精度，不调用np.isclose默认策略。
+            a, b, atol, rtol = (to_float_numpy(item) for item in values)
+            # 左边abs(a-b)，非有限中间结果UNKNOWN。
+            distance = unary_numpy('abs', binary_numpy('sub', a, b))
+            # 右边rtol*abs(b)，保持判据非对称。
+            relative = binary_numpy('mul', rtol, unary_numpy('abs', b))
+            # atol+relative真实float64列。
+            tolerance = binary_numpy('add', atol, relative)
+            # 不把非有限容差当作可正常无限阈值。
+            value = binary_numpy('le', distance, tolerance)
+            # 计算中间诊断同步纳入整列统计。
+            diagnostic |= a.quality | b.quality | atol.quality | rtol.quality | distance.quality | tolerance.quality
+        else:
+            # 只对静态白名单operator执行真实批量数值。
+            value = binary_numpy(node.operator, values[0], values[1], allow_float_literal=node.allow_float_literal)
+        # known逻辑输出可以有效，诊断是独立原因列。
+        result = ArrayEvaluation(value, diagnostic | value.quality)
+    # 局部cache只存当前批列结果。
+    cache[node] = result
+    # 不持有跨调用输入绑定或信号状态。
+    return result
+
+
+def evaluate_numpy(compiled: CompiledExpression, context, bindings: SignalBindings | DecodedBindings | MessageBindings, *, size: int | None = None) -> ArrayEvaluation:
+    """检查绑定、依赖列与行数后，批量计算一个表达式。
+
+    参数:
+        compiled: 当前CompiledExpression；bindings为对应普通或MessageBindings运行绑定。
+        context: 以精确依赖别名为键的NumericArray映射；所有列须同长同布局。
+        size: 可选的非负行数N。可从第一列推断，纯常量无依赖时必须显式提供。
+    返回:
+        ArrayEvaluation，结果和诊断均为形状(N,)的独立只读数组，允许N为零。
+    异常:
+        TypeError、ValueError: 模型、绑定身份、依赖键、类型、枚举域或形状不合法。
+        数值失败追加质量原因；内存分配异常直接传播。
+    边界:
+        不广播或补齐错位列。每次调用创建新缓存，只复用当前批次的公共子树。
+    """
+    # 共享协议校验不包含参考数据计算。
+    require_context(compiled, context, bindings)
+    # 显式行数不得用bool或任意隐式整数对象替代。
+    if size is not None and (type(size) is not int or size < 0):
+        # 不按int truthiness解读shape。
+        raise TypeError('size需要非负原生int')
+    # 每个实际依赖列都需相同当前dtype和enum域。
+    for name, value in context.items():
+        # 对照当前真实定义，不从全局查找。
+        definition = bindings.resolve(name)
+        # 不接裸数组或错误类型并偷偷astype。
+        if not isinstance(value, NumericArray) or value.dtype is not definition.dtype:
+            # 类型错误不能补成UNKNOWN。
+            raise TypeError('context列dtype与当前绑定不同')
+        # 当前声明固定标签域。
+        labels = tuple(dict.fromkeys(label for _, label in definition.choices)) if definition.dtype is D.ENUM else ()
+        # 相同代码但不同域不允许。
+        if value.labels != labels:
+            # 来源语义必须明确隔离。
+            raise ValueError('context enum域不同')
+        # 没有显式行数时取第一合法列，不broadcast。
+        if size is None:
+            # 只有真正数据列决定N。
+            size = len(value.values)
+        # 错行数必须执行前拒绝。
+        if len(value.values) != size:
+            # 不补齐或截断以凑shape。
+            raise ValueError('context各列shape不同')
+    # 常量无依赖也不能猜输出行数。
+    if size is None:
+        # 此时context为空，没有合法可推断shape。
+        raise ValueError('纯常量批量执行须明确size')
+    # 每次批量求值创建新缓存；编译树可复用，上一批的数值结果不继承。
+    return _evaluate(compiled.root, context, size, {})
+
+
+def evaluate_memory_numpy(compiled: CompiledExpression, times: np.ndarray, *, point: bool = False) -> ArrayEvaluation:
+    """从已有内存信号批量对齐到查询时间，再计算表达式。
+
+    参数:
+        compiled: 关联真实输入的CompiledExpression。
+        times: 非递减的一维int64纳秒轴，形状(N,)；point控制真实末点查询视图。
+    返回:
+        同形状ArrayEvaluation，保留有效掩码、质量原因和绑定身份。
+    异常:
+        TypeError: 非memory绑定，包括DecodedBindings；其他时间/归属/形状异常原样传播。
+    流程:
+        只建立实际依赖的历史列，独立归一化并按有效期对齐，再整列求值。
+        纯常量也检查时间轴；保留完整历史，结果复制存储，不额外读取或解码。
+    """
+    # 纯常量也不能绕过memory来源门槛，显式错误避免解码绑定缺session属性的偶发异常。
+    if not isinstance(compiled, CompiledExpression) or not isinstance(compiled.bindings, SignalBindings):
+        raise TypeError('memory快捷求值需要真实SignalBindings的CompiledExpression')
+    # 常量表达式也校验真正时间轴，拒绝MaskArray/回退/浮点时间。
+    _require_axis(times)
+    # 末点控制必须明确bool，不猜truthiness。
+    if type(point) is not bool:
+        # 保持协议与reference一致。
+        raise TypeError('point需要bool')
+    # 局部context只材料化实际依赖列。
+    context = {}
+    # 循环维度是依赖列，列内对齐/计算实际数组化。
+    for name in compiled.dependencies:
+        # 原输出→独立NumPy额外转换，不重复DBC factor。
+        history = memory_series_numpy(compiled.bindings, name)
+        # 用searchsorted定位最近观测，并结合有效期与质量掩码决定哪些保持值可用。
+        aligned = align_numpy(build_signal_array(history), times, point=point)
+        # 原valid/质量保留，包括最新invalid覆盖，enum代码域来自历史。
+        context[name] = NumericArray(history.bindings.resolve(name).dtype, aligned.values, aligned.valid, aligned.quality, aligned.history.labels)
+    # 精确行数还覆盖无依赖/空查询情况。
+    return evaluate_numpy(compiled, context, compiled.bindings, size=len(times))

chronaxis/core/expression_reference.py

@@ -0,0 +1,272 @@
+"""用独立标量计算求值表达式，并保留未知结果的原因。
+
+evaluate_reference接收当前CompiledExpression、真实普通或消息绑定和context。
+context按依赖别名提供ScalarValue，输出Evaluation，分别保存计算结果和
+全部被求值依赖的质量原因。evaluate_memory_reference还可从已有内存行
+提取信号，经参考转换和按时间保持后，在给定纳秒坐标逐点求值。
+
+布尔表达式使用TRUE、FALSE、UNKNOWN（未知）三种状态。例如FALSE and
+UNKNOWN可确定为FALSE，TRUE or UNKNOWN可确定为TRUE；被遮蔽的异常
+仍保留在dependency_quality中。isclose按abs(a-b) <= atol + rtol*abs(b)
+计算，两种容差均由表达式显式提供，非有限中间值不能变成正常判断。
+
+只依赖标准库和参考数值、对齐模块，不执行任意Python代码，也不读取
+旧日志或额外解码。当前求值缓存不跨时间点保留，不调用NumPy数值内核。
+"""
+
+# 冻结结果保证逻辑质量与诊断质量清楚分离。
+from dataclasses import dataclass
+# context只接受真实映射，不反射对象属性。
+from collections.abc import Mapping
+# 用静态编译模型和当前真实绑定校验身份。
+from .expression import CompiledExpression
+# 已校验输入绑定不能用用户字符串冒充。
+from .binding import SignalBindings
+# 解码绑定由实际历史核对工厂生成；本入口不创建伪造内存来源。
+from .decoded_binding import DecodedBindings
+# 消息仓使用独立绑定；只接受其显式context，不引入时间保持或原历史。
+from .message_binding import MessageBindings
+# 独立参考数值内核，内部比较映射只有标准运算。
+from .numeric import (COMPARE_FUNCTIONS, ScalarValue, binary_reference, memory_series_reference,
+                      to_float_reference, unary_reference)
+# 独立参考保持为memory查询生成输入。
+from .state import align_reference
+# 三值使用BOOL的valid，不将UNKNOWN默认转False。
+from .types import QualityFlag as Q, SignalDType as D
+
+
+@dataclass(frozen=True)
+class Evaluation:
+    """分别保存可用的计算结果，以及本次求值的全部质量诊断。
+
+    value是ScalarValue，其quality表示结果本身不可用的原因。
+    dependency_quality另存依赖和计算的原因并集；即使已知FALSE或TRUE使
+    布尔结果可以确定，原来的异常也仍可追溯，不能强塞回正常结果的quality。
+    实例不可重新赋值，不保存下一个时间点的信号状态。
+    """
+
+    value: ScalarValue  # 实际逻辑输出。
+    dependency_quality: Q  # 原依赖/本次计算的全部诊断并集。
+
+
+def require_context(compiled, context, bindings):
+    """核对表达式的输入身份和调用者提供的依赖名称。
+
+    参数:
+        compiled: 可执行CompiledExpression；context为真实映射对象。
+        bindings: 当前SignalBindings、DecodedBindings或MessageBindings，须与编译身份一致。
+    返回:
+        None。context的键必须恰好等于dependencies，纯常量表达式需空映射。
+    异常:
+        TypeError: 计划、映射或绑定模型类型不合法。
+        ValueError: 绑定身份不同，或依赖键缺失、多余。
+    边界:
+        只校验结构，不读来源、不求值；各个值的类型由后续执行入口检查。
+    """
+    # 执行不能仅凭表达式文本或语义名复用旧绑定。
+    if (not isinstance(compiled, CompiledExpression) or not isinstance(bindings, (SignalBindings, DecodedBindings, MessageBindings))
+            or not isinstance(compiled.bindings, (SignalBindings, DecodedBindings, MessageBindings)) or not isinstance(context, Mapping)):
+        # 不把接口配置错吞为UNKNOWN。
+        raise TypeError('执行需要CompiledExpression/context及真实普通或消息绑定')
+    # 相同结构名称不证明输入数据/转换/TTL相同。
+    if compiled.bindings.identity != bindings.identity:
+        # 必须重新编译真实当前绑定。
+        raise ValueError('可执行表达式与当前输入绑定身份不同')
+    # 普通解码核实际投影，消息绑定核单来源依赖；两者均拒绝静态声明冒充运行域。
+    if isinstance(bindings, (DecodedBindings, MessageBindings)):
+        bindings.require_synchronized(compiled.dependencies)
+    # 禁止缺列/错误列映射/隐式全局取值。
+    if set(context) != set(compiled.dependencies):
+        # 常量表达式context为空，不猜未提供信号。
+        raise ValueError('context必须精确提供表达式dependencies')
+
+
+def _logic(operator, values):
+    """独立标量三值and/or/not，不以UNKNOWN当False。
+
+    参数: operator固定逻辑名，values为BOOL ScalarValue tuple。
+    返回: ScalarValue；正常决断quality NONE，未知保留原因并集。
+    异常: 调用侧静态类型保证，不接数值truthiness。
+    """
+    # not对未知仍保持原原因。
+    if operator == 'not':
+        # known TRUE/FALSE取反，不使用Truth.__bool__。
+        return ScalarValue(not values[0].value, D.BOOL) if values[0].valid else ScalarValue(None, D.BOOL, False, values[0].quality)
+    # 所有原因仍在外层Evaluation诊断保存。
+    quality = Q.NONE
+    # 标量参考逐逻辑值判断，允许独立状态循环。
+    for value in values:
+        # 同一操作原始原因不丢失。
+        quality |= value.quality
+    # 对称规则：任一已知False决定and，已知True决定or。
+    deciding = False if operator == 'and' else True
+    # invalid数值占位不参与判断，不能False-like导致决断。
+    if any(value.valid and value.value is deciding for value in values):
+        # 结果已知，原异常仍由外层依赖诊断保存。
+        return ScalarValue(deciding, D.BOOL)
+    # 没有决断值且有unknown，结果仍未知。
+    if quality != Q.NONE:
+        # 保留真实未知原因而非一律MISSING。
+        return ScalarValue(None, D.BOOL, False, quality)
+    # 所有已知：and全部TRUE，or全部FALSE。
+    return ScalarValue(not deciding, D.BOOL)
+
+
+def _evaluate(node, context, cache):
+    """用独立参考数值解释单个冻结节点及局部公共子树。
+
+    参数: node静态树；context当前typed值；cache仅本次point局部缓存。
+    返回: Evaluation，完整诊断与逻辑有效性分开。
+    异常: 静态模型/类型错误直接传播，不eval或吞配置异常。
+    """
+    # 公共表达式复用只限同一点/当前真实输入。
+    if node in cache:
+        # 不跨point继承旧信号值。
+        return cache[node]
+    # 常量字面量已由编译器完成上下文dtype/域检查。
+    if node.operator == 'const':
+        # dtype/labels构造不能任意隐式转值。
+        value = ScalarValue(node.value, node.dtype, labels=node.labels)
+        # literal没有原信号异常。
+        result = Evaluation(value, Q.NONE)
+    # 只使用当前显式context的简单名称。
+    elif node.operator == 'name':
+        # 输入包装身份与dtype由外层入口校验。
+        value = context[node.name]
+        # 上游全部质量同时作为诊断保留。
+        result = Evaluation(value, value.quality)
+    else:
+        # 子树全部求值以保留原依赖异常，即使逻辑已可决断。
+        children = tuple(_evaluate(arg, context, cache) for arg in node.args)
+        # 当前节点可用逻辑结果，不是原诊断值。
+        values = tuple(child.value for child in children)
+        # 诊断汇总包括已被已知逻辑结果遮蔽的异常。
+        diagnostic = Q.NONE
+        # 此为独立标量参考循环，不共享数组归约内核。
+        for child in children:
+            # 原因并集不会被normal BOOL清除。
+            diagnostic |= child.dependency_quality
+        # 三值逻辑独立于数值质量门槛。
+        if node.operator in ('and', 'or', 'not'):
+            # FALSE and UNKNOWN与TRUE or UNKNOWN都可确定结果，diagnostic仍保存原原因。
+            value = _logic(node.operator, values)
+        # 数值单目用已验收的独立参考函数。
+        elif node.operator in ('abs', 'neg'):
+            # int64 min依然严格OVERFLOW。
+            value = unary_reference(node.operator, values[0])
+        # float信号上下文中的整数literal显式精度检查。
+        elif node.operator == 'to_float':
+            # 不能通过编译隐藏舍入整数。
+            value = to_float_reference(values[0])
+        # 精确整数比较literal可以超过64位边界。
+        elif node.operator.startswith('int_literal_'):
+            # Python整数参考绝不先转float。
+            value = ScalarValue(COMPARE_FUNCTIONS[node.operator[12:]](values[0].value, node.value), D.BOOL) if values[0].valid else ScalarValue(None, D.BOOL, False, values[0].quality)
+        # isclose严格按明确非对称判据，拒绝默认容差。
+        elif node.operator == 'isclose':
+            # 四个数值都经各自严格float精度检查。
+            a, b, atol, rtol = (to_float_reference(item) for item in values)
+            # 判据abs(a-b)，非有限中间值仍显式UNKNOWN。
+            distance = unary_reference('abs', binary_reference('sub', a, b))
+            # 右边rtol*abs(b)的参考IEEE路径。
+            relative = binary_reference('mul', rtol, unary_reference('abs', b))
+            # atol与relative依旧用明确数值质量规则。
+            tolerance = binary_reference('add', atol, relative)
+            # 不把非有限容差当无穷阈值正常通过。
+            value = binary_reference('le', distance, tolerance)
+            # 当前中间数值原因也纳入原依赖诊断。
+            diagnostic |= a.quality | b.quality | atol.quality | rtol.quality | distance.quality | tolerance.quality
+        else:
+            # 编译树只包含注册二元数值/比较，不执行自由函数。
+            value = binary_reference(node.operator, values[0], values[1], allow_float_literal=node.allow_float_literal)
+        # 结果原因是诊断子集，known决断不丢所有依赖质量。
+        result = Evaluation(value, diagnostic | value.quality)
+    # 仅当前point的公共子树值可以复用。
+    cache[node] = result
+    # 冻结结果不持有跨调用可变状态。
+    return result
+
+
+def evaluate_reference(compiled: CompiledExpression, context: Mapping, bindings: SignalBindings | DecodedBindings | MessageBindings) -> Evaluation:
+    """检查当前标量输入后，对表达式进行一次独立参考求值。
+
+    参数:
+        compiled: 当前CompiledExpression；bindings为对应的普通或MessageBindings运行绑定。
+        context: 以精确依赖别名为键的ScalarValue映射，声明类型与枚举域须匹配。
+    返回:
+        Evaluation，区分正常或未知的计算结果，并保留所有依赖的质量诊断。
+    异常:
+        TypeError、ValueError: 依赖键、模型、类型、枚举域或绑定身份不合法。
+        数值计算失败写入质量原因，不把配置错误当作缺失数据。
+    边界:
+        每次调用使用新缓存，只复用本次求值中的公共子树，不继承上一次的值。
+    """
+    # 静态执行身份和列映射须执行前成立。
+    require_context(compiled, context, bindings)
+    # 校验真实当前dtype和枚举域，不能只靠上下文名字。
+    for name, value in context.items():
+        # 冻结定义来自当前真实绑定。
+        definition = bindings.resolve(name)
+        # 只有typed标量可执行，不把裸float当信号。
+        if not isinstance(value, ScalarValue) or value.dtype is not definition.dtype:
+            # 输入类型冲突不是样本缺失。
+            raise TypeError('context值与当前signal dtype不一致')
+        # enum域需与真实映射一致。
+        labels = tuple(dict.fromkeys(item for _, item in definition.choices)) if definition.dtype is D.ENUM else ()
+        # 不让不同任务同名code域串入。
+        if value.labels != labels:
+            # 命名一致不证明语义域一致。
+            raise ValueError('context enum域与绑定不同')
+    # 每个时间点都创建新缓存，避免沿用上个时间点的信号值。
+    return _evaluate(compiled.root, context, {})
+
+
+def evaluate_memory_reference(compiled: CompiledExpression, times: tuple[int, ...], *, point: bool = False) -> tuple[Evaluation, ...]:
+    """从已有内存行取得信号，在指定纳秒坐标逐点计算表达式。
+
+    参数:
+        compiled: 关联真实内存输入的CompiledExpression。
+        times: 非递减的整数纳秒元组；point控制真实末点查询视图。
+    返回:
+        与times等长的Evaluation元组，保存正常值、未知状态和依赖诊断。
+    异常:
+        TypeError: 非memory绑定，包括DecodedBindings；其他时间/来源/配置异常原样传播。
+    边界:
+        只提取实际依赖，先归一化再按有效期保持；纯常量也检查时间轴。
+        为完整内存历史建立新对象，不读取文件、额外解码或修改原行。
+    """
+    # 纯常量也须明确拒绝解码绑定，不能借空依赖意外进入memory快捷路径。
+    if not isinstance(compiled, CompiledExpression) or not isinstance(compiled.bindings, SignalBindings):
+        raise TypeError('memory快捷求值需要真实SignalBindings的CompiledExpression')
+    # 仅材料化当前实际依赖，不改变旧链筛选或扫描次数。
+    histories = {name: memory_series_reference(compiled.bindings, name) for name in compiled.dependencies}
+    # 参考保持与数组查询实现独立。
+    aligned = {name: align_reference(series, times, point=point) for name, series in histories.items()}
+    # 当前memory空依赖也需严格校验时间/视图接口。
+    if not histories:
+        # 常量没有来源，时间轴依旧遵守typed ns协议。
+        from ..timebase.conversion import require_int64_ns
+        # 不能将自由序列或int truthiness解释成合法时间轴。
+        if not isinstance(times, tuple) or type(point) is not bool:
+            # 同参考保持输入结构要求。
+            raise TypeError('times需tuple且point需bool')
+        # 每个坐标仍必须合法定宽且不回退。
+        for index, time in enumerate(times):
+            # 精确整数时间不经float转换。
+            require_int64_ns(time, 'time_ns')
+            # 不排序用户输入掩盖异常。
+            if index and time < times[index-1]:
+                # 空依赖也不是时间回退豁免。
+                raise ValueError('时间轴回退')
+    # 当前点只使用已对齐的真实结果，invalid原值保留。
+    results = []
+    # 标量参考允许逐时间解释，不冒充数组化。
+    for index in range(len(times)):
+        # 当前局部context不跨时间保存数值。
+        context = {name: ScalarValue(states[index].value, compiled.bindings.resolve(name).dtype, states[index].valid, states[index].quality,
+                                     tuple(dict.fromkeys(label for _, label in compiled.bindings.resolve(name).choices)) if compiled.bindings.resolve(name).dtype is D.ENUM else ())
+                   for name, states in aligned.items()}
+        # 完整绑定身份再次门槛校验后运行真实参考。
+        results.append(evaluate_reference(compiled, context, compiled.bindings))
+    # 返回不可变结果，不持有全局任务状态。
+    return tuple(results)

chronaxis/core/integral_result.py

@@ -0,0 +1,53 @@
+"""将完整积分事实与已换单位的数值组合成既有 CalculationResult。
+
+输入必须是同一 IntegralReduction 交付的两项冻结结果；不创建虚假 CalculationSeries。
+先校验单位、覆盖划分和计数，再复用既有 report/strict 与最低覆盖门槛分类。
+本层没有积分数值核，不重复换单位，也不把输入质量中的非有限直接当整窗计算失败。
+无文件副作用；分类会复制未知区间容器，调用方须事先预约元数据工作空间。
+纯模型不含共同运行凭据，结构校验不能证明来源配对，实际 owner 负责保证。
+"""
+
+# 共享非数值分类规则，两个积分后端仍独立；真实 facts 自带完整身份和定位。
+from .integral_terms import IntegralFacts
+from .integral_sum import IntegralSumResult
+from .calculations import CalculationResult, calculation_unit, make_calculation_result
+
+
+def make_integral_result(facts: IntegralFacts, number: IntegralSumResult) -> CalculationResult:
+    """把同一归约的数值及完整覆盖按现有政策归类。
+
+    参数: facts 为完整真实交集事实；number 为已经换成最终单位的数值快照。
+    返回: CalculationResult，保留原请求、样本、未知范围、质量及完整来源子类。
+    异常: TypeError/ValueError 为模型、单位、范围或计数矛盾；分配错误传播。
+    边界: 无条件积分，已知条件时长等于实际跨度；没有全 FALSE 的选择证据。
+    """
+    # 不以任意对象提供的同名属性冒充真实冻结结果，单位只校验而不再乘因子。
+    if not isinstance(facts, IntegralFacts) or not isinstance(number, IntegralSumResult):
+        raise TypeError('积分分类需要IntegralFacts和IntegralSumResult')
+    unit, _ = calculation_unit(facts.spec, facts.input_unit)
+    if number.unit != unit:
+        raise ValueError('积分数值输出单位与原请求不一致')
+    actual, request = facts.actual_window, facts.spec.window
+    duration = 0 if actual is None else actual.end_ns - actual.start_ns
+    if actual is not None and not request.start_ns <= actual.start_ns <= actual.end_ns <= request.end_ns:
+        raise ValueError('积分实际观测越过原请求')
+    # 每个有效面积对应正整数纳秒区间；真实有效更新不能多于有效面积项。
+    if (not 0 <= facts.valid_sample_count <= number.valid_term_count <= facts.value_valid_duration_ns
+            or (number.valid_term_count == 0) != (facts.value_valid_duration_ns == 0)):
+        raise ValueError('积分面积项数、有效时长与真实样本不一致')
+    # 严格检查完整划分，不能用重复未知范围或缺失区间伪造覆盖。
+    cursor = 0 if actual is None else actual.start_ns
+    unknown_duration = 0
+    for interval in facts.value_unknown_ranges:
+        if interval.start_ns < cursor:
+            raise ValueError('积分未知范围需有序且不重叠')
+        cursor = interval.end_ns
+        unknown_duration += interval.end_ns - interval.start_ns
+    if unknown_duration + facts.value_valid_duration_ns != duration:
+        raise ValueError('积分有效与未知时长未完整划分实际窗口')
+    # 现有分类只从第二参数取identity/refs，直接提供真实facts，不伪造全窗信号列。
+    return make_calculation_result(facts.spec, facts, number.value, number.unit, actual,
+                              facts.value_valid_duration_ns, duration, facts.value_valid_duration_ns,
+                              unknown_duration, facts.valid_sample_count, facts.value_unknown_ranges, (),
+                              facts.quality | number.quality, all_false=False,
+                              calculation_failed=number.calculation_failed)