先加一个大数，再加1：那个1为什么消失了，又怎样把它找回来？

"""Compare rounded sums against the exact sum of the stored float inputs."""
from fractions import Fraction
from itertools import permutations, product
import math
import sys


def require(condition, message):
    if not condition:
        raise AssertionError(message)


def accumulate(values, mode, trace=False):
    if not isinstance(values, (list, tuple)):
        raise TypeError("list or tuple required for this teaching experiment")
    if mode not in ("naive", "kahan", "neumaier"):
        raise ValueError("unknown mode")
    if len(values) > 10000 or any(type(x) is not float or not math.isfinite(x)
                                or abs(x) > 1e100 for x in values):
        raise ValueError("at most 10000 finite floats with abs(x) <= 1e100")
    total, correction, events = 0.0, 0.0, []
    for i, x in enumerate(values):
        if mode == "naive":
            total = total + x
        elif mode == "kahan":
            adjusted = x - correction
            next_total = total + adjusted
            correction = (next_total - total) - adjusted
            total = next_total
        else:
            next_total = total + x
            if abs(total) >= abs(x):
                correction += (total - next_total) + x
            else:
                correction += (x - next_total) + total
            total = next_total
        if trace:
            events.append((i, x, total, correction))
    result = total + correction if mode == "neumaier" else total
    return result, events


def exact_sum(values):
    result = Fraction(0)
    for x in values:
        result += Fraction.from_float(x)
    return result


def main():
    require(sys.float_info.radix == 2 and sys.float_info.mant_dig == 53, "binary64 required")
    modes = ("naive", "kahan", "neumaier")
    examples = [
        ("small_increments", [1e16, 1.0, 1.0, -1e16], (0.0, 2.0, 2.0), 2),
        ("kahan_counterexample", [1e16, 1.0, -1e16], (0.0, 0.0, 1.0), 1),
        ("neumaier_counterexample", [1e100, 1e16, 1.0, -1e100, -1e16], (-1e16, -1e16, 0.0), 1),
        ("empty", [], (0.0, 0.0, 0.0), 0),
    ]
    for label, values, expected, rational in examples:
        actual = tuple(accumulate(values, mode)[0] for mode in modes)
        exact = exact_sum(values)
        require(actual == expected and exact == rational, label)
        require(math.fsum(values) == float(exact), "fsum comparison")
        print(f"{label}: naive={actual[0]}; kahan={actual[1]}; neumaier={actual[2]}; exact={exact}")
    for mode in ("kahan", "neumaier"):
        _, events = accumulate([1e16, 1.0, -1e16], mode, trace=True)
        for i, x, total, correction in events:
            print(f"{mode}: i={i}; x={x}; total={total}; correction={correction}")
    alphabet = (0.0, 1.0, -1.0, 1e16, -1e16, 1e-16, -1e-16)
    mismatches = dict.fromkeys(modes, 0)
    cases = 0
    for n in range(6):
        for values in product(alphabet, repeat=n):
            rounded_reference = float(exact_sum(values))
            require(math.fsum(values) == rounded_reference, "fsum differs on finite test domain")
            for mode in modes:
                actual = accumulate(values, mode)[0]
                mismatches[mode] += actual != rounded_reference
            cases += 1
    require(all(mismatches[m] > 0 for m in modes), "each teaching algorithm has counterexamples")
    permutation_matches = dict.fromkeys(modes, 0)
    for values in permutations((1e16, 1.0, -1e16)):
        for mode in modes:
            permutation_matches[mode] += accumulate(values, mode)[0] == 1.0
    require(permutation_matches == {"naive": 2, "kahan": 2, "neumaier": 6}, "order matters")
    lost_at_input = [float(10**16 + 1), -1e16]
    require(exact_sum(lost_at_input) == 0, "conversion already lost one")
    require(all(accumulate(lost_at_input, m)[0] == 0.0 for m in modes), "cannot recover input")
    invalid = [lambda: accumulate([1], "naive"), lambda: accumulate([True], "kahan"),
               lambda: accumulate([math.inf], "neumaier"), lambda: accumulate([math.nan], "naive"),
               lambda: accumulate([1e101], "kahan"), lambda: accumulate([0.0] * 10001, "naive"),
               lambda: accumulate(iter([1.0]), "naive"), lambda: accumulate([], "unknown")]
    rejected = 0
    for action in invalid:
        try:
            action()
        except (TypeError, ValueError):
            rejected += 1
        else:
            raise AssertionError("invalid input accepted")
    print(f"finite_sequences={cases}; rounded_reference_mismatches={mismatches}")
    print(f"six_permutations_correct={permutation_matches}; input_conversion_exact_sum={exact_sum(lost_at_input)}")
    print(f"rejected_inputs={rejected}; fsum_checked={cases + len(examples)}")
    print("PASS: counterexamples reproduced; no universal exactness claim")


if __name__ == "__main__":
    main()