chronaxis 0.1.0.dev0__py3-none-any.whl

chronaxis/core/calculations_reference.py

@@ -0,0 +1,294 @@
+"""独立计算保持值积分、时间统计、TRUE时长和真实样本统计。
+
+compute_reference接收CalculationSeries和CalculationDefinition，先裁剪观测与请求窗口，
+再独立计算面积、样本归约、覆盖时长及未知区间，输出CalculationResult。
+积分使用零阶保持：左端值乘以相邻区间裁剪后的时长。先对整数纳秒端点
+求差，再换算秒，不把较大的绝对时间先转成浮点数。
+时间极值包含裁剪边界的保持值，time_weighted_mean按有效选择时长加权；duration
+累计有效主BOOL为TRUE的区间。select_reference保留真实TRUE/UNKNOWN更新行。
+
+样本统计只取actual_value_updates为True的真实数值更新，不包含窗口或
+有效期到期边界，也不包括半开窗口末点。值有效与条件已知分别统计，
+条件FALSE是已知未选中，UNKNOWN（未知）不能视作FALSE或补成零。
+
+本实现只使用标准库与核心模型，数值和覆盖不调用NumPy。可共享输入
+检查、单位与结果分类，但归约独立实现。保留完整内存输入，不读写文件，
+不修改原数据或持有跨任务状态；本模块不提供流式内存预算保证。
+"""
+
+# 独立标量有限性/稳定求和，不调用数组归约。
+from math import fsum, isfinite
+# 共享模型、单位与条件始终为FALSE时的空选择规则，不共享数值计算。
+from .calculations import CalculationSeries, CalculationDefinition, make_calculation_result, calculation_unit
+# 诊断区间与请求都保持精确纳秒。
+from .models import Interval
+# 独立参考定宽到float转换先检查精度。
+from .numeric import ScalarValue, to_float_reference
+# 未知/计算质量与正常零严格分开。
+from .types import QualityFlag as Q, SignalDType as D, Truth
+# 选择只共享冻结协议，标量筛选独立于NumPy掩码。
+from .selection import SelectionRow, require_selection
+from .record_intervals import clipped_record_seconds, require_record_step
+
+
+def require_calculation(series, spec, *, step_ns=None):
+    """验证实际指标输入模型，不执行任何面积或统计。
+
+    参数: series真实CalculationSeries，spec真实CalculationDefinition；step_ns可指定记录对周期，
+        仅连续统计算子可用，输入必须是所选驱动真实更新。
+    返回: None，模型内部完整轴和dtype已校验。
+    异常: TypeError为无类型占位输入；ValueError为select标量执行或dtype不匹配。
+    """
+    # 后端共享typed协议，不复用被测数值。
+    if not isinstance(series, CalculationSeries) or not isinstance(spec, CalculationDefinition):
+        # 不猜dict内不完整状态。
+        raise TypeError('指标执行需CalculationSeries和CalculationDefinition')
+    # 行流具有独立返回类型，不能作为标量统计执行。
+    if spec.operation == 'select':
+        raise ValueError('select需选择行流入口')
+    # 布尔只用于TRUE时长；数值统计不接受布尔或枚举编码。
+    allowed = (D.BOOL,) if spec.operation == 'duration' else (D.INT64, D.UINT64, D.FLOAT64)
+    if series.values[0].dtype not in allowed:
+        raise ValueError('指标算子与输入dtype不匹配')
+    if step_ns is not None and spec.operation not in ('integral', 'duration', 'time_weighted_mean', 'min_time', 'max_time'):
+        raise ValueError('样本统计不接受记录对周期')
+    require_record_step(step_ns, series.actual_value_updates)
+
+
+def select_reference(series, spec):
+    """按真实更新逐行返回TRUE与UNKNOWN选择结果，不累计输出列表。
+
+    参数: series完整内存CalculationSeries；spec为select请求。
+    返回: SelectionRow迭代器；UNKNOWN保留诊断，FALSE排除，窗口右端不输出。
+    异常: 开始迭代时传播模型/算子/单位错误。
+    流程: 遍历完整时间轴，只处理请求与观测交集内的真实目标依赖更新。
+        合成边界与条件独自更新不产生行；无效值保持原质量，不填正常零。
+    """
+    # 生成器检查发生在消费时；只共享输入门槛。
+    require_selection(series, spec)
+    start = max(spec.window.start_ns, series.observation.start_ns)
+    end = min(spec.window.end_ns, series.observation.end_ns)
+    # 输入已经完整物化，输出每次只创建当前行。
+    for index, time in enumerate(series.times_ns):
+        # 不插入保持值行、不读取EOF之后的数据。
+        if not start <= time < end or not series.actual_value_updates[index]:
+            continue
+        # 未提供条件就是明确TRUE，未知条件单独诊断。
+        condition = series.conditions[index] if series.conditions is not None else ScalarValue(True, D.BOOL)
+        selection = Truth.UNKNOWN if not condition.valid else Truth.TRUE if condition.value else Truth.FALSE
+        if selection is Truth.FALSE:
+            continue
+        # 原值保持dtype/质量/标签与绑定，UNKNOWN不是自动选择成功。
+        value = series.values[index]
+        yield SelectionRow(time, value, selection, series.diagnostics[index] | value.quality | condition.quality,
+                           series.binding_identity, series.source_refs, series.unit)
+
+
+def compute_reference(series, spec, *, step_ns=None):
+    """独立计算请求窗口内的积分、样本/时间统计或BOOL TRUE时长。
+
+    参数:
+        series: 完整CalculationSeries；数值统计需同一数值dtype，duration需BOOL。
+        spec: CalculationDefinition，给出左闭右开纳秒窗口、算子、输出单位和部分结果政策。
+        step_ns: 可选固定/DBC周期，仅用于所选驱动的真实记录对；按交集比例
+            计算面积、时长和均值权重，不改变实际坐标或输出第二套时间。
+    返回:
+        CalculationResult。未换单位的整数极值可保持精确整数；积分和样本平均
+        返回浮点值；时间平均先规范化时长权重，duration输出秒。无法核实时
+        为None，并保留覆盖、来源与质量原因；select使用独立行流入口。
+    异常:
+        输入模型或单位配置错误直接传播TypeError或ValueError。
+        非有限结果、下溢或转换丢精度作为质量原因返回，不吞配置错误。
+    流程:
+        裁剪窗口后逐区间计算保持面积与三值选择交集，再按真实更新归约样本，
+        最后应用一次输出单位转换并分类结果。正常零与未知占位分别处理。
+        临时值和诊断列表只用于本次计算，不修改调用者的CalculationSeries。
+    """
+    # 配置错误不能吞成未知数据。
+    require_calculation(series, spec, step_ns=step_ns)
+    # 仅显式已知维度转换，保留有符号面积。
+    unit, factor = calculation_unit(spec, series.unit)
+    # 先求真实观测与请求交集，不外推末点/EOF。
+    start = max(spec.window.start_ns, series.observation.start_ns)
+    # 半开窗口右端实际观测不足必须裁剪。
+    end = min(spec.window.end_ns, series.observation.end_ns)
+    # 完全无交集与零域分别由政策解释。
+    actual = Interval(start, end) if start <= end else None
+    # 整数输入进入float面积/mean前先严格验证，不影响精确min/max。
+    values = [to_float_reference(value) if spec.operation in ('integral', 'sample_mean', 'time_weighted_mean') else value for value in series.values]
+    # 全部覆盖时长使用Python精确整数，不按样本数量估算。
+    value_duration, known_duration, selected_duration, selected_unknown = 0, 0, 0, 0
+    # 明确FALSE时长用来证明充分观测空选择，不靠sum空数组。
+    false_duration = 0
+    # 真实未知区间按原因类型分别记录，不改变原输入。
+    value_unknown, condition_unknown, areas = [], [], []
+    # 时间统计保留每个正裁剪区间的左端保持值和整数纳秒时长。
+    timed_values = []
+    # duration必须至少有可核实的主布尔值与TRUE选择区间，不能靠外部UNKNOWN补零。
+    duration_evidence = 0
+    # 原诊断与计算原因完整OR，不将KNOWN逻辑结果改成UNKNOWN。
+    quality = Q.NONE
+    # 独立参考逐区间求裁剪/面积/三值交集。
+    for index in range(len(series.times_ns)-1):
+        # 先裁剪精确整数端点，不先转float绝对坐标。
+        left, right = max(series.times_ns[index], start), min(series.times_ns[index+1], end)
+        # 窗口外或零区间不产生面积/未知时长。
+        if left >= right:
+            # 边界point不是额外周期。
+            continue
+        # 先整数差再换算秒，保留大绝对时间的小间隔。
+        duration = right - left
+        # 当前ZOH值与当前选择独立有效性。
+        value = values[index]
+        # 无条件表示明确选择全部，而不是未知选择。
+        condition = series.conditions[index] if series.conditions is not None else ScalarValue(True, D.BOOL)
+        # 原依赖、数值与条件质量均可追溯。
+        quality |= series.diagnostics[index] | value.quality | condition.quality
+        # 正常积分面积先计算，非有限/下溢不变成正常0。
+        area = None
+        # 只计算真实选择的有效值，FALSE不制造所选值缺失。
+        if spec.operation == 'integral' and value.valid and condition.valid and condition.value:
+            # 相对dt转秒，默认ZOH保持当前左端值。
+            seconds = (duration / 1_000_000_000 if step_ns is None else
+                       clipped_record_seconds(series.times_ns[index], series.times_ns[index + 1],
+                                              spec.window, step_ns=step_ns))
+            area = value.value * seconds
+            # 有限输入乘积溢出和非零乘积下溢显式失效。
+            failure = Q.NONFINITE if not isfinite(area) else Q.PRECISION_LOSS if area == 0 and value.value != 0 else Q.NONE
+            # 不参与不可信面积的正常归约。
+            if failure != Q.NONE:
+                # 元数据值仍保留，只有计算输出置未知。
+                value = ScalarValue(value.value, D.FLOAT64, False, failure)
+                # 相同真实样本的积分可用性也更新。
+                values[index] = value
+                # 新原因不覆盖原诊断。
+                quality |= failure
+        # 值有效时长与条件真假独立统计。
+        if value.valid:
+            # 有效零值计入覆盖，区别于UNKNOWN。
+            value_duration += duration
+        else:
+            # 不跨窗口外范围保存未知。
+            value_unknown.append(Interval(left, right))
+        # 条件UNKNOWN独立保存；FALSE属于已知条件覆盖。
+        if condition.valid:
+            # 真假都可判断，不把FALSE当缺失。
+            known_duration += duration
+            # 只有明确FALSE累计空选择证据。
+            if not condition.value:
+                # 不凭无选中结果推测FALSE。
+                false_duration += duration
+            # 真与有效值交集才算选中时长。
+            elif value.valid:
+                # FALSE主值仍证明已知零时长；外部条件未知不提供该证据。
+                duration_evidence += duration
+                # 所选面积和时长分别保留。
+                selected_duration += duration if spec.operation != 'duration' or value.value else 0
+                # 其他样本算子没有连续面积。
+                if spec.operation == 'integral':
+                    # 正常零面积合法进入归约。
+                    areas.append(area)
+                # min/max_time包含裁剪左边界保持值，time_weighted_mean使用同一有效选择集合。
+                if spec.operation in ('min_time', 'max_time', 'time_weighted_mean'):
+                    weight = (clipped_record_seconds(series.times_ns[index], series.times_ns[index + 1],
+                                                     spec.window, step_ns=step_ns)
+                              if spec.operation == 'time_weighted_mean' and step_ns is not None else duration)
+                    timed_values.append((value.value, weight))
+                elif spec.operation == 'duration' and value.value and step_ns is not None:
+                    areas.append(clipped_record_seconds(series.times_ns[index], series.times_ns[index + 1],
+                                                        spec.window, step_ns=step_ns))
+            else:
+                # 所选值未知时strict/report有必要覆盖不足。
+                selected_unknown += duration
+        else:
+            # 条件未知不能当FALSE产生空选择零。
+            condition_unknown.append(Interval(left, right))
+    # 样本口径只计真实原依赖更新，不计TTL/裁剪合成边界。
+    selected_samples = []
+    # 参考逐原完整时间组统计当前值/条件，不跨域复制末点。
+    for index, time in enumerate(series.times_ns):
+        # 半开实际窗口内真实更新，末点排除。
+        if not start <= time < end or not series.actual_value_updates[index]:
+            # 不把窗口左端保持值伪装成真实样本。
+            continue
+        # 未知样本保留在诊断，只有有效/TRUE进入样本统计。
+        value = values[index]
+        # 无选择条件全部真实有效样本可用。
+        condition = series.conditions[index] if series.conditions is not None else ScalarValue(True, D.BOOL)
+        # 完整实际样本的质量也纳入诊断。
+        quality |= series.diagnostics[index] | value.quality | condition.quality
+        # 不将无效原数据存储占位0当正常样本。
+        if value.valid and condition.valid and condition.value and (spec.operation != 'duration' or value.value):
+            # 仅恢复当前原生逻辑数值，未改原输入。
+            selected_samples.append(value.value)
+    # 空归约保持None；仅明确all_false时按空选择规则处理。
+    result, failed = None, False
+    # 已选可核实面积或样本才计算正常值。
+    try:
+        # 面积与样本统计使用不同明确口径。
+        if spec.operation == 'integral' and areas:
+            # fsum减少标量累计舍入，但不替代NumPy归约。
+            result = fsum(areas)
+        # 精确整数极值无需浮点转换。
+        elif selected_samples and spec.operation == 'sample_minimum':
+            # 窗口裁剪不增加边界合成样本。
+            result = min(selected_samples)
+        # 同样保留uint64大整数精度。
+        elif selected_samples and spec.operation == 'sample_maximum':
+            # min/max不按时间加权。
+            result = max(selected_samples)
+        # mean明确样本算术平均，不叫模糊mean。
+        elif selected_samples and spec.operation == 'sample_mean':
+            # 有效样本数量作分母，不能用时长替代。
+            result = fsum(selected_samples) / len(selected_samples)
+        # 时间极值只计正时长保持区间，保留大整数的原生精度。
+        elif timed_values and spec.operation == 'min_time':
+            result = min(value for value, _ in timed_values)
+        elif timed_values and spec.operation == 'max_time':
+            result = max(value for value, _ in timed_values)
+        # 先规范化权重，避免平均值有限但值乘纳秒的中间面积溢出。
+        elif timed_values and spec.operation == 'time_weighted_mean':
+            denominator = selected_duration if step_ns is None else fsum(weight for _, weight in timed_values)
+            terms = [value * (duration / denominator) for value, duration in timed_values]
+            if any(not isfinite(term) for term in terms):
+                failed, quality = True, quality | Q.NONFINITE
+            elif any(term == 0 and value != 0 for term, (value, _) in zip(terms, timed_values)):
+                failed, quality = True, quality | Q.PRECISION_LOSS
+            else:
+                result = fsum(terms)
+        # 已知FALSE可核实为零；全未知没有候选值，不能返回正常零。
+        elif spec.operation == 'duration' and duration_evidence > 0:
+            result = selected_duration / 1_000_000_000 if step_ns is None else fsum(areas)
+    # 只把明确浮点累计溢出转计算质量，不吞接口错误。
+    except OverflowError:
+        # 无法核实总值不报正常Inf。
+        failed, quality = True, quality | Q.NONFINITE
+    # 输出转换仅一次；未转换整数极值保持整数。
+    if result is not None and not failed:
+        # 非单位1倍率转换整数前仍检查精度。
+        if factor != 1 and type(result) is int:
+            # 静态单位不会授权无声丢大整数精度。
+            converted = to_float_reference(ScalarValue(result, series.values[0].dtype))
+            # 失败输出null且原覆盖/来源诊断保留。
+            if not converted.valid:
+                # 明确PRECISION_LOSS，不截断原整数。
+                failed, quality = True, quality | converted.quality
+            else:
+                # 仅已证明正常整数才浮点换单位。
+                result = converted.value
+        # 不把失败结果继续乘因子。
+        if not failed:
+            # factor1保留整数，避免无必要cast。
+            original = result
+            # 数学单位转换，不改变符号方向。
+            result = result * factor if factor != 1 else result
+            # 非有限和非零下溢都不能报正常0。
+            if type(result) is float and (not isfinite(result) or result == 0 and original != 0):
+                # 明确归约/转换失败；不修改coverage来伪造通过。
+                failed, quality = True, quality | (Q.NONFINITE if not isfinite(result) else Q.PRECISION_LOSS)
+    # 完整全FALSE证明需要非零实际域，最后政策还检查请求充分覆盖。
+    all_false = series.conditions is not None and actual is not None and end > start and false_duration == end-start
+    # 共同政策仅包装各独立内核已计算的事实。
+    return make_calculation_result(spec, series, result, unit, actual, value_duration, known_duration, selected_duration,
+                              selected_unknown, len(selected_samples), value_unknown, condition_unknown, quality,
+                              all_false=all_false, calculation_failed=failed)

chronaxis/core/condition_evidence.py

@@ -0,0 +1,182 @@
+"""把同轴的更新前点、连续后态及当前点求值结果组装成条件证据。
+
+输入为调用方已经求出的三个BOOL视图、整数纳秒轴，以及实际更新、真实无效更新、
+来源结束和会话terminal四种独立标志；输出冻结ConditionTick tuple。更新前点只用于
+证明真实更新是否导致UNKNOWN，不把其反事实诊断加入当前真实诊断。terminal强制
+连续状态UNKNOWN并叠加MISSING，当前点仍可保留真正末点的TRUE或FALSE。
+参考实现逐点使用标量结果，数组实现独立执行valid/quality与因果掩码运算，最后装箱。
+本模块不求值表达式、不读取来源、不访问state或时钟、不生成时间轴，也不更新检测器。
+数组临时列及输出规模随N增长，后续调用方必须先申请预算；本纯内核不是有限执行器。
+NumPy只在数组入口加载，参考入口及模块导入保持标准库核心的依赖边界。
+"""
+
+# 已求值结果和冻结证据共享协议；这里不调用任一表达式或保持数值核。
+from .expression_reference import Evaluation
+from .numeric import ScalarValue
+from .temporal import ConditionTick
+from .types import QualityFlag as Q, SignalDType as D, Truth
+# 参考轴先要求原生int，再沿用已有int64端点检查，不进行t-1或差分运算。
+from ..timebase.conversion import require_int64_ns
+
+
+def _reference_truth(result):
+    """把已经验证的BOOL标量转为三值，未知存储占位不参加真假判断。
+
+    参数: result当前Evaluation，调用入口已检查ScalarValue及BOOL声明。
+    返回: Truth.TRUE、Truth.FALSE或Truth.UNKNOWN。
+    异常: 无主动异常；调用者必须先完成typed结果校验。
+    """
+    # valid先于值解释，无效None/False等占位都只表示UNKNOWN。
+    if not result.value.valid:
+        return Truth.UNKNOWN
+    # 只有已验证的原生BOOL正常值进入二值分支，不对任意数值使用truthiness。
+    return Truth.TRUE if result.value.value else Truth.FALSE
+
+
+def condition_ticks_reference(times, before, continuous, point, actual_updates,
+                              invalid_updates, observation_ends, terminals):
+    """独立逐点组装完整条件证据，不从来源推断更新标志或补造时间。
+
+    参数:
+        times: 原生int构成的tuple，单位ns，int64范围内严格递增。
+        before/continuous/point: 同长Evaluation tuple，三个视图的结果dtype均为BOOL。
+        actual_updates: 同长原生bool tuple，当前条件依赖中是否有真实更新。
+        invalid_updates: 同长原生bool tuple，实际选中的更新样本是否无效；
+            不把保持值因TTL到期而无效算作真实无效更新，True必须同时有actual。
+        observation_ends: 同长原生bool tuple，条件依赖的来源是否在此刻结束观测。
+        terminals: 同长原生bool tuple，会话连续域是否结束；至多唯一末项，
+            不要求同时存在来源EOF，普通批次全False与空输入均合法。
+    返回:
+        tuple[ConditionTick, ...]，保留连续/点质量、真实因果及当前依赖诊断。
+    异常:
+        TypeError为容器、原生元素、模型或非BOOL；ValueError为长度、回退/重复时间、
+        非末terminal或invalid缺actual；OverflowError为时间越界；MemoryError为分配失败。
+    副作用:
+        只创建当前有限输入的输出模型，不修改任何输入；申请预算由调用者负责。
+    """
+    # 明确固定tuple协议，不能从任意迭代器隐式收集全量来源。
+    columns = (before, continuous, point, actual_updates, invalid_updates, observation_ends, terminals)
+    if type(times) is not tuple or any(type(column) is not tuple for column in columns):
+        raise TypeError('参考条件证据需要时间、三视图及四标志tuple')
+    # 行数必须已经对齐，禁止zip静默截断或广播修补错位证据。
+    size = len(times)
+    if any(len(column) != size for column in columns):
+        raise ValueError('条件证据各输入长度必须相同')
+    # 时间不接受bool/NumPy标量；直接比较避免极值差分或t-1溢出。
+    previous = None
+    for time in times:
+        if type(time) is not int:
+            raise TypeError('参考条件证据时间需要原生int纳秒')
+        require_int64_ns(time)
+        if previous is not None and time <= previous:
+            raise ValueError('条件证据时间必须严格递增')
+        previous = time
+    # 四种标志不能用整数或字符串真假代替真实证据。
+    for column in (actual_updates, invalid_updates, observation_ends, terminals):
+        if any(type(value) is not bool for value in column):
+            raise TypeError('参考条件证据标志需要原生bool')
+    # 任一前置terminal都会违反唯一末组契约；普通批次允许完全没有terminal。
+    if any(terminals[index] for index in range(max(0, size - 1))):
+        raise ValueError('terminal只能唯一出现在输入末项')
+    if any(invalid and not actual for invalid, actual in zip(invalid_updates, actual_updates)):
+        raise ValueError('真实无效更新必须同时有actual_update')
+    # Evaluation自身不验证字段，先核对真实标量/诊断协议与BOOL声明再解释值。
+    for column in (before, continuous, point):
+        for result in column:
+            if (not isinstance(result, Evaluation) or not isinstance(result.value, ScalarValue)
+                    or not isinstance(result.dependency_quality, Q)):
+                raise TypeError('参考三视图需要typed Evaluation/ScalarValue/QualityFlag')
+            if result.value.dtype is not D.BOOL:
+                raise TypeError('条件证据三视图必须为BOOL，数值不能隐式转bool')
+    # 参考逐点只使用当前三个结果；不调用数组实现或重新查询历史。
+    ticks = []
+    for index, time in enumerate(times):
+        old, current, observed = before[index], continuous[index], point[index]
+        old_state = _reference_truth(old)
+        state, point_state = _reference_truth(current), _reference_truth(observed)
+        # known更新前点、实际无效或新增结果质量位证明未知来自真实更新。
+        causal = (invalid_updates[index] or old_state is not Truth.UNKNOWN
+                  or bool(observed.value.quality & ~old.value.quality))
+        actual_unknown = actual_updates[index] and point_state is Truth.UNKNOWN and causal
+        # 半开连续域在真实terminal结束，但不更改闭区间当前点的证据。
+        quality = current.value.quality
+        if terminals[index]:
+            state, quality = Truth.UNKNOWN, quality | Q.MISSING
+        # 仅当前连续与当前点的依赖原因属于真实诊断，before反事实原因排除。
+        diagnostic = current.dependency_quality | observed.dependency_quality
+        ticks.append(ConditionTick(time, state, quality, actual_updates[index],
+                                   observation_ends[index], terminals[index], point_state,
+                                   observed.value.quality, actual_unknown, diagnostic))
+    # 冻结输出供检测器按完整组推进；空输入自然得到空tuple。
+    return tuple(ticks)
+
+
+def condition_ticks_numpy(times, before, continuous, point, actual_updates,
+                          invalid_updates, observation_ends, terminals):
+    """独立按列构造因果与三值证据，最后仅恢复不可变ConditionTick模型。
+
+    参数:
+        times: 精确ndarray，一维int64纳秒轴，严格递增。
+        before/continuous/point: 同轴ArrayEvaluation，NumericArray逻辑dtype为BOOL。
+        actual_updates: 精确ndarray，形状(N,)的bool真实更新列。
+        invalid_updates: 同形状bool列，实际选中更新样本无效；TTL不属于真实更新，
+            True必须有同时刻actual_updates=True。
+        observation_ends: 同形状bool列，条件依赖的来源观测结束标志。
+        terminals: 同形状bool列，会话连续域结束标志，至多唯一末项；
+            不要求来源EOF同时成立，空轴及无terminal合法。
+    返回:
+        tuple[ConditionTick, ...]；数值/因果计算整列完成，装箱不调用参考实现。
+    异常:
+        TypeError为数组布局、模型或非BOOL；ValueError为shape、非递增时间或矛盾标志；
+        MemoryError为列/输出分配失败。不隐式cast、不调用vectorize或标量参考数值核。
+    内存与副作用:
+        临时状态/quality/因果/诊断列均为(N,)，不修改借用的输入；预算须由调用者先申请。
+    """
+    # 延迟加载数组依赖，使只导入/使用参考入口时不引入NumPy。
+    import numpy as np
+    from .expression_numpy import ArrayEvaluation
+    from .numeric_numpy import NumericArray
+    # 轴的物理布局明确，不用asarray/astype隐式转换任意输入。
+    if type(times) is not np.ndarray or times.ndim != 1 or times.dtype != np.dtype('int64'):
+        raise TypeError('数组条件证据时间需要一维精确int64 ndarray')
+    # 比较相邻坐标而非np.diff，INT64_MIN到INT64_MAX的合法递增不会回绕。
+    if np.any(times[1:] <= times[:-1]):
+        raise ValueError('条件证据时间必须严格递增')
+    # 四标志是同形状bool列；禁止广播或对象数组真值进入因果运算。
+    for column in (actual_updates, invalid_updates, observation_ends, terminals):
+        if type(column) is not np.ndarray or column.ndim != 1 or column.dtype != np.dtype('bool'):
+            raise TypeError('数组条件证据标志需要一维精确bool ndarray')
+        if column.shape != times.shape:
+            raise ValueError('条件证据标志与时间shape必须相同')
+    # 终点只能是当前输入末项，真实无效标志必须有同时刻实际更新。
+    if np.any(terminals[:-1]):
+        raise ValueError('terminal只能唯一出现在输入末项')
+    if np.any(invalid_updates & ~actual_updates):
+        raise ValueError('真实无效更新必须同时有actual_update')
+    # 三个静态视图复用已校验模型，仅检查本次BOOL和同轴布局；不复制或重新求值。
+    for result in (before, continuous, point):
+        if not isinstance(result, ArrayEvaluation) or not isinstance(result.value, NumericArray):
+            raise TypeError('数组三视图需要typed ArrayEvaluation/NumericArray')
+        if result.value.dtype is not D.BOOL:
+            raise TypeError('条件证据三视图必须为BOOL，数值不能隐式转bool')
+        if result.value.values.shape != times.shape or result.dependency_quality.shape != times.shape:
+            raise ValueError('条件证据三视图与时间shape必须相同')
+    # 因果来自实际invalid、更新前known或点结果新增质量位，整列掩码独立于参考。
+    causal = (invalid_updates | before.value.valid
+              | ((point.value.quality & ~before.value.quality) != 0))
+    actual_unknown = actual_updates & ~point.value.valid & causal
+    # 形状(N,)的整数状态列使用0/1/2对应TRUE/FALSE/UNKNOWN；无效False占位不决定真值。
+    continuous_states = np.where(continuous.value.valid, np.where(continuous.value.values, 0, 1), 2)
+    point_states = np.where(point.value.valid, np.where(point.value.values, 0, 1), 2)
+    # 只修改新建连续列，terminal不延长面积；借用的点结果与质量保持原样。
+    continuous_states[terminals] = 2
+    quality = continuous.value.quality.copy()
+    quality[terminals] |= np.uint16(Q.MISSING)
+    # 当前实际诊断整列合并，刻意排除更新前反事实诊断。
+    diagnostic = continuous.dependency_quality | point.dependency_quality
+    # 列运算已完成，只在末端把形状(N,)存储恢复为原生int/bool及枚举模型。
+    truths = (Truth.TRUE, Truth.FALSE, Truth.UNKNOWN)
+    return tuple(ConditionTick(int(time), truths[int(continuous_states[index])], Q(int(quality[index])),
+                               bool(actual_updates[index]), bool(observation_ends[index]), bool(terminals[index]),
+                               truths[int(point_states[index])], Q(int(point.value.quality[index])),
+                               bool(actual_unknown[index]), Q(int(diagnostic[index]))) for index, time in enumerate(times))

chronaxis/core/conditional_integral_result.py

@@ -0,0 +1,43 @@
+"""组合完整条件积分事实与已换单位数值，复用既有结果政策。
+
+只有正请求完整观测且条件全程已知FALSE才能证明空选择为0。
+UNKNOWN、无实际观测和零窗口保持无法判断，部分值按report/strict政策交付。
+本模块只核对模型、单位和项数，不重复面积、求和或单位转换。
+输入须来自同一实际归约owner，纯结构不能证明该配对；分类需要复制有限
+未知诊断容器，外层必须提前预约元数据内存。本模块不读文件或改变输入。
+"""
+
+# 共用的非数值分类不影响参考/NumPy面积及原序归约的独立性。
+from .conditional_integral_terms import ConditionalIntegralFacts
+from .integral_sum import IntegralSumResult
+from .calculations import CalculationResult, calculation_unit, make_calculation_result
+
+
+def make_conditional_integral_result(facts: ConditionalIntegralFacts, number: IntegralSumResult) -> CalculationResult:
+    """把完整覆盖与数值快照分类，保留TRUE/FALSE/UNKNOWN和原来源。
+
+    参数: facts为整窗真实事实，number为同一owner最终换单位后的数值快照。
+    返回: CalculationResult；原数值质量与输入原因完整合并，FALSE零由既有政策产生。
+    异常: TypeError/ValueError为类型、单位或样本/面积项数矛盾；分配错误传播。
+    """
+    if not isinstance(facts, ConditionalIntegralFacts) or not isinstance(number, IntegralSumResult):
+        raise TypeError('条件积分分类需要ConditionalIntegralFacts和IntegralSumResult')
+    if not facts.ranges_retained:
+        raise ValueError('完整结果不能将未保留范围当成没有未知区间')
+    unit, _ = calculation_unit(facts.spec, facts.input_unit)
+    if number.unit != unit:
+        raise ValueError('条件积分数值单位与原请求不一致')
+    # 每项只对应正整数纳秒区间；样本不是TTL/条件单独更新，不能超过正常面积项数。
+    if (not facts.valid_sample_count <= number.valid_term_count <= facts.selected_duration_ns
+            or (number.valid_term_count == 0) != (facts.selected_duration_ns == 0)):
+        raise ValueError('条件积分样本、正常面积项数与选择时长不一致')
+    actual = facts.actual_window
+    span = 0 if actual is None else actual.end_ns - actual.start_ns
+    all_false = actual is not None and span > 0 and actual == facts.spec.window and facts.false_duration_ns == span
+    # facts本身带身份/来源；无需伪造完整CalculationSeries或把无条件事实改成条件事实。
+    return make_calculation_result(facts.spec, facts, number.value, number.unit, actual,
+                              facts.value_valid_duration_ns, facts.condition_known_duration_ns,
+                              facts.selected_duration_ns, facts.selected_value_unknown_duration_ns,
+                              facts.valid_sample_count, facts.value_unknown_ranges, facts.condition_unknown_ranges,
+                              facts.quality | number.quality, all_false=all_false,
+                              calculation_failed=number.calculation_failed)