This strategy compares return distributions across aggregation scales using one-dimensional monotone transport. It does not estimate a robust regression slope through quantile points. Its hypothesis is that a broad, directionally consistent translation of the recent return distribution relative to older, more aggregated distributions may identify an ongoing directional regime. A distribution that merely becomes wider or changes shape should receive less confidence than one whose probability mass shifts coherently in one direction.

Three equal-sized empirical supports are constructed. The recent support contains the newest 32 individual returns. The intermediate support contains 32 averages of three consecutive returns from indices 32 through 127. The reference support contains 32 averages of four consecutive returns from indices 128 through 255. Each support is sorted independently. Every sorted observation has mass 1/32. Matching equal ranks is the monotone optimal coupling for the absolute-distance transport cost in one dimension. No iterative transport solver or external numerical library is required.

For sorted rank j, define move[j] = recent[j] - reference[j]. The first transport distance is W1 = mean(abs(move[j])), while signed displacement is shift = mean(move[j]). Shape deformation is shape = mean(abs(move[j]-shift)). The intermediate signed shift is measured against the same reference support. The model also counts the fractions of ranks moving upward and downward, obtaining consistency = abs(up_fraction - down_fraction). Reference dispersion is the standard deviation of the reference support, not a sample estimate of a contemporaneous tradable spread.

The heuristic quality is consistency*abs(shift)/(W1 + shape), with numerical floors where necessary. This expression penalizes cancellation and deformation. The recent and intermediate signed shifts must agree, and quality must exceed the model's internal threshold before execution is considered. A standardized displacement z = shift/(reference_spread + shape) becomes edge = z/sqrt(1+z^2). Positive displacement supports a long, negative displacement supports a short, and the maximum holding duration is eight hourly bars. Shared entry and exit gates remain an additional layer rather than replacing this transport logic.

A key limitation is that averaging three or four returns changes distribution width even under an unchanged process. Therefore this implementation studies displacement across explicitly different aggregation scales; it does not pretend that all three supports are draws from identical marginal distributions. Sorting also discards temporal order within each support, so an isolated rearrangement can leave the transport measure unchanged. Tail shocks can move several summary quantities at once. Synthetic symmetry and rejection checks help validate implementation behavior, but they cannot determine whether coherent transport displacement forecasts continuation after spread, commission, and slippage. That empirical question requires separate market-data evaluation.

Code
// TS14_TransportShift: Optimal transport distribution displacement.
// Standalone model implementation with embedded safety and engine code.
// Market scope: EUR/USD completed-hour return aggregation horizons.
// These are not actual bond maturities or a futures calendar spread.
// Model diagnostic: Wasserstein displacement divided by reference spread.
// Quality heuristic: Directional mass agreement and translation relative to deformation.
// Limitation: Averaging changes distribution width; interpretation is displacement across aggregation scales, not identical marginals.
// No claim of profitability, calibration, or independent strategy returns.
// Inputs: 256 newest-first log returns; all must be finite and within [-1,1].
// Output: bounded signed edge; positive buys, negative sells, zero abstains.
// Quality is a heuristic filter, never a calibrated success probability.
// The synthetic suite below is included in the total file line count.
// Regenerate with build_sources.py; compare hashes before deployment.
#include <default.c>
string TS2Algo = "TS14";
string TS2TestLog = "Log/TS14_TransportShift_test.txt";
int TS2Holding = 8;
// R1/R3: IEEE-754 finite validation without lite-C unordered comparisons.
// Supported Zorro Windows targets use 64-bit var and little-endian 32-bit int.
int TSIsFinite(var Value)
{
    int Words[2];
    memcpy(Words, &Value, sizeof(Value));
    return (Words[1] & 0x7ff00000) != 0x7ff00000;
}

// Forex commission per lot; negative quotes are percent, not cash rebates.
// Return -1 on invalid metadata rather than accepting an unknown risk amount.
var TSFeePerLot(var FeeQuote, var UnitsPerLot, var PipSize, var PipValue, var RefPrice)
{
    var FeeValue;
    if (!TSIsFinite(FeeQuote) || !TSIsFinite(UnitsPerLot) || !TSIsFinite(PipSize) ||
        !TSIsFinite(PipValue) || !TSIsFinite(RefPrice))
        return -1.;
    if (!(UnitsPerLot > 0.) || !(PipSize > 0.) || !(PipValue > 0.) || !(RefPrice > 0.))
        return -1.;
    if (FeeQuote >= 0.)
        FeeValue = FeeQuote * UnitsPerLot / 10000.;
    else
        FeeValue = (-FeeQuote / 100.) * (PipValue / PipSize) * RefPrice;
    if (!TSIsFinite(FeeValue) || FeeValue < 0.)
        return -1.;
    return FeeValue;
}

var TSUnitStopRisk(var RefPrice)
{
    var FeeValue, FeePrice, StopRisk;
    if (!TSIsFinite(RefPrice) || !(RefPrice > 0.) || !TSIsFinite(Stop) || !(Stop > 0.) ||
        !TSIsFinite(Spread) || !TSIsFinite(Balance) || !TSIsFinite(Equity) ||
        !TSIsFinite(MarginCost) || !TSIsFinite(MarginVal))
        return -1.;
    if (!(Balance > 0.) || !(Equity > 0.) || !(MarginCost > 0.))
        return -1.;
    // Conservative percentage-fee price through the stop, absent gaps/slippage.
    FeePrice = RefPrice + abs(Spread) + Stop;
    FeeValue = TSFeePerLot(Commission, LotAmount, PIP, PIPCost, FeePrice);
    if (FeeValue < 0.)
        return -1.;
    StopRisk = (Stop + abs(Spread)) / PIP * PIPCost + FeeValue;
    if (!TSIsFinite(StopRisk) || !(StopRisk > 0.))
        return -1.;
    return StopRisk;
}

// Embedded input, state, and test contracts; identical safety is not novel alpha.
#define TS2_N 256
var TS2Returns[256];
var TS2Quality;
var TS2Statistic;
var TS2Raw;
int TS2Checks;
int TS2Failures;
var TS2Model();
var TS2Bound(var Value)
{
    if (!TSIsFinite(Value))
        return 0.;
    return max(-1., min(1., Value));
}
var TS2Evaluate()
{
    int Index;
    var Energy;
    TS2Quality = 0.;
    TS2Statistic = 0.;
    TS2Raw = 0.;
    Energy = 0.;
    for (Index = 0; Index < TS2_N; Index++)
    {
        if (!TSIsFinite(TS2Returns[Index]))
            return 0.;
        if (abs(TS2Returns[Index]) > 1.)
            return 0.;
        Energy += TS2Returns[Index] * TS2Returns[Index];
    }
    if (Energy < 1.e-24)
        return 0.;
    TS2Raw = TS2Model();
    if (!TSIsFinite(TS2Raw) || abs(TS2Raw) > 1.e12 ||
        !TSIsFinite(TS2Quality) || !TSIsFinite(TS2Statistic))
    {
        TS2Quality = 0.;
        TS2Statistic = 0.;
        TS2Raw = 0.;
        return 0.;
    }
    TS2Quality = max(0., min(1., TS2Quality));
    return TS2Bound(TS2Raw);
}
void TS2Expect(int Passed, string Label)
{
    TS2Checks++;
    if (!Passed)
    {
        TS2Failures++;
        file_append(TS2TestLog, strf("FAIL: %s\n", Label));
    }
}
// BEGIN ANALYTICAL MODEL
// One-dimensional monotone optimal transport compares entire distributions.
// This is distribution translation, not a quantile-slope curve fit.
var TS2Model()
{
    var Recent[32], Reference[32], Middle[32], Movement[32];
    var Key, Wasserstein, SignedShift, Deformation, Center, Dispersion;
    var Intermediate, LongShift, Consistency, PositiveMass, NegativeMass;
    var Common, Distance, Scale, Signal;
    int Index, Position, Block;
    for (Index = 0; Index < 32; Index++)
    {
        Recent[Index] = TS2Returns[Index];
        Middle[Index] = 0.;
        Reference[Index] = 0.;
        for (Block = 0; Block < 3; Block++)
            Middle[Index] += TS2Returns[32 + 3 * Index + Block] / 3.;
        for (Block = 0; Block < 4; Block++)
            Reference[Index] += TS2Returns[128 + 4 * Index + Block] / 4.;
    }
    // Equal-probability supports; insertion sort has deterministic tie handling.
    for (Index = 1; Index < 32; Index++)
    {
        Key = Recent[Index];
        Position = Index - 1;
        while (Position >= 0)
        {
            if (Recent[Position] <= Key)
                break;
            Recent[Position + 1] = Recent[Position];
            Position--;
        }
        Recent[Position + 1] = Key;
        Key = Middle[Index];
        Position = Index - 1;
        while (Position >= 0)
        {
            if (Middle[Position] <= Key)
                break;
            Middle[Position + 1] = Middle[Position];
            Position--;
        }
        Middle[Position + 1] = Key;
        Key = Reference[Index];
        Position = Index - 1;
        while (Position >= 0)
        {
            if (Reference[Position] <= Key)
                break;
            Reference[Position + 1] = Reference[Position];
            Position--;
        }
        Reference[Position + 1] = Key;
    }
    Wasserstein = 0.; SignedShift = 0.; Intermediate = 0.;
    PositiveMass = 0.; NegativeMass = 0.; Center = 0.;
    for (Index = 0; Index < 32; Index++)
    {
        Movement[Index] = Recent[Index] - Reference[Index];
        Wasserstein += abs(Movement[Index]) / 32.;
        SignedShift += Movement[Index] / 32.;
        Intermediate += (Middle[Index] - Reference[Index]) / 32.;
        Center += Reference[Index] / 32.;
        if (Movement[Index] > 0.)
            PositiveMass += 1. / 32.;
        if (Movement[Index] < 0.)
            NegativeMass += 1. / 32.;
    }
    Dispersion = 0.; Deformation = 0.;
    for (Index = 0; Index < 32; Index++)
    {
        Dispersion += pow(Reference[Index] - Center, 2.) / 32.;
        Deformation += abs(Movement[Index] - SignedShift) / 32.;
    }
    Scale = sqrt(Dispersion);
    Consistency = abs(PositiveMass - NegativeMass);
    TS2Statistic = Wasserstein / max(1.e-16, Scale);
    TS2Quality = Consistency * abs(SignedShift) / max(1.e-16, Wasserstein + Deformation);
    if (SignedShift * Intermediate <= 0. || TS2Quality < 0.35)
        return 0.;
    Signal = SignedShift / max(1.e-16, Scale + Deformation);
    return Signal / sqrt(1. + Signal * Signal);
}
// END ANALYTICAL MODEL

// Separate repair regression log; the original suite counts stay intact.
int TSRepairChecks = 0;
int TSRepairFailures = 0;
string TSRepairLog = "Log/TS14_TransportShift_repair.txt";
void TSRepairCheck(int Passed, string Label)
{
    TSRepairChecks++;
    if (!Passed)
    {
        TSRepairFailures++;
        file_append(TSRepairLog, strf("FAIL: %s\n", Label));
    }
}
var TSRepairBad(int Kind)
{
    int Bits[2];
    var Value;
    Bits[0] = 0;
    Bits[1] = 0x7ff80000;
    if (Kind == 1) Bits[1] = 0x7ff00000;
    if (Kind == 2) Bits[1] = 0xfff00000;
    memcpy(&Value, Bits, sizeof(Value));
    return Value;
}
void TSRepairTests()
{
    int I, Kind, Position;
    var FeeValue, UnitLoss, Budget;
    TSRepairChecks = 0; TSRepairFailures = 0;
    file_write(TSRepairLog, "Repairs R1-R5: native-safe regression suite\n", 0);
    TSRepairCheck(sizeof(FeeValue) == 8, "64-bit var representation");
    TSRepairCheck(TSIsFinite(0.), "finite zero");
    TSRepairCheck(TSIsFinite(1.), "finite positive");
    TSRepairCheck(TSIsFinite(-1.), "finite negative");
    for (Kind = 0; Kind < 3; Kind++)
        TSRepairCheck(!TSIsFinite(TSRepairBad(Kind)), "reject NaN and both infinities");
    TSRepairCheck(abs(TSFeePerLot(0.7, 1000., 0.0001, 0.1, 1.1) - 0.07) < 1.e-6,
                  "cash commission convention");
    TSRepairCheck(TSFeePerLot(0., 1000., 0.0001, 0.1, 1.1) == 0., "zero commission");
    FeeValue = TSFeePerLot(-0.02, 1000., 0.0001, 0.1, 1.1);
    TSRepairCheck(abs(FeeValue - 0.22) < 1.e-6, "percentage commission convention");
    TSRepairCheck(TSFeePerLot(0.7, 1000., 0., 0.1, 1.1) < 0., "invalid pip size");
    TSRepairCheck(TSFeePerLot(0.7, 1000., 0.0001, 0., 1.1) < 0., "invalid pip value");
    TSRepairCheck(TSFeePerLot(0.7, 0., 0.0001, 0.1, 1.1) < 0., "invalid lot amount");
    TSRepairCheck(TSFeePerLot(0.7, 1000., 0.0001, 0.1, -1.) < 0., "invalid fee price");
    TSRepairCheck(TSFeePerLot(TSRepairBad(0), 1000., 0.0001, 0.1, 1.1) < 0., "NaN fee quote");
    TSRepairCheck(TSFeePerLot(-0.02, 1000., 0.0001, 0.1, TSRepairBad(1)) < 0., "infinite fee price");
    TSRepairCheck(TSFeePerLot(-0.02, 1000., TSRepairBad(0), 0.1, 1.1) < 0., "NaN pip metadata");
    UnitLoss = (20. * 0.0001 + 0.0001) / 0.0001 * 0.1 + FeeValue;
    Budget = 850. * 0.0025;
    TSRepairCheck(floor(Budget / UnitLoss) == 0., "percentage fee respects lot-rounding budget");

    for (Kind = 0; Kind < 3; Kind++)
    {
        for (Position = 0; Position < 2; Position++)
        {
            for (I = 0; I < 256; I++) TS2Returns[I] = 0.0005 + 0.0001 * sin(0.3 * I);
            TS2Returns[Position] = TSRepairBad(Kind);
            TSRepairCheck(TS2Evaluate() == 0, "non-finite consumed input rejected");
            TSRepairCheck(TS2Quality == 0., "invalid return clears quality");
        }
    }
    
    file_append(TSRepairLog, strf("RESULT: %d checks; %d failures\n", TSRepairChecks, TSRepairFailures));
}
// Synthetic property tests: executed only with -d TS2_SELFTEST.
// Tests do not execute trades, query market data, or establish profitability.
// Known-response anchor: not just a generic bounded-output assertion.
void TS2KnownResponse()
{
    int I;
    var Edge, Negative;
    for (I = 0; I < 256; I++)
        TS2Returns[I] = 0.0005;
    Edge = TS2Evaluate();
    TS2Expect(Edge == 0., "known straight path: model-specific response");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -0.0005;
    Negative = TS2Evaluate();
    TS2Expect(abs(Edge + Negative) < 1.e-7, "known straight path: symmetric response");
}
void TS2KnownTranslation()
{
    int I;
    var Edge;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = 0.001;
        if (I < 128)
            TS2Returns[I] = 0.002;
        if (I < 32)
            TS2Returns[I] = 0.003;
    }
    Edge = TS2Evaluate();
    TS2Expect(Edge > 0.99, "translated point masses: positive transport edge");
    TS2Expect(TS2Quality > 0.99, "translated point masses: full transport coherence");
}
// Case 1: slow_sine; model 14 perturbation phase 1.918000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case1()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = 0.0008 * sin(0.07 * I);
        TS2Returns[I] += 0.00000003 * sin(1.918000 + I * 0.372000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "slow_sine: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "slow_sine: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "slow_sine: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "slow_sine: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "slow_sine: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "slow_sine: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[14] = 2.;
    TS2Expect(TS2Evaluate() == 0., "slow_sine: implausible return rejected");
    TS2Expect(TS2Quality == 0., "slow_sine: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "slow_sine: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "slow_sine: quality restored");
}
// Case 2: fast_sine; model 14 perturbation phase 1.918000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case2()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = 0.0012 * sin(1.1 * I);
        TS2Returns[I] += 0.00000003 * sin(1.918000 + I * 0.372000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "fast_sine: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "fast_sine: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "fast_sine: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "fast_sine: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "fast_sine: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "fast_sine: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[51] = 2.;
    TS2Expect(TS2Evaluate() == 0., "fast_sine: implausible return rejected");
    TS2Expect(TS2Quality == 0., "fast_sine: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "fast_sine: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "fast_sine: quality restored");
}
// Case 3: two_scale_beating; model 14 perturbation phase 1.918000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case3()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = 0.0009 * sin(0.18 * I) + 0.0007 * sin(0.21 * I);
        TS2Returns[I] += 0.00000003 * sin(1.918000 + I * 0.372000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "two_scale_beating: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "two_scale_beating: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "two_scale_beating: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "two_scale_beating: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "two_scale_beating: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "two_scale_beating: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[88] = 2.;
    TS2Expect(TS2Evaluate() == 0., "two_scale_beating: implausible return rejected");
    TS2Expect(TS2Quality == 0., "two_scale_beating: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "two_scale_beating: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "two_scale_beating: quality restored");
}
// Case 4: amplitude_burst; model 14 perturbation phase 1.918000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case4()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = 0.0004 * sin(0.31 * I) * (1. + 3. * exp(-pow((I - 28.) / 8., 2.)));
        TS2Returns[I] += 0.00000003 * sin(1.918000 + I * 0.372000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "amplitude_burst: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "amplitude_burst: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "amplitude_burst: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "amplitude_burst: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "amplitude_burst: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "amplitude_burst: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[125] = 2.;
    TS2Expect(TS2Evaluate() == 0., "amplitude_burst: implausible return rejected");
    TS2Expect(TS2Quality == 0., "amplitude_burst: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "amplitude_burst: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "amplitude_burst: quality restored");
}
// Case 5: chirp_acceleration; model 14 perturbation phase 1.918000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case5()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = 0.001 * sin(0.0018 * I * I + 0.05 * I);
        TS2Returns[I] += 0.00000003 * sin(1.918000 + I * 0.372000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "chirp_acceleration: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "chirp_acceleration: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "chirp_acceleration: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "chirp_acceleration: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "chirp_acceleration: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "chirp_acceleration: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[162] = 2.;
    TS2Expect(TS2Evaluate() == 0., "chirp_acceleration: implausible return rejected");
    TS2Expect(TS2Quality == 0., "chirp_acceleration: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "chirp_acceleration: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "chirp_acceleration: quality restored");
}
// Case 6: chirp_deceleration; model 14 perturbation phase 1.918000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case6()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = 0.001 * sin(7. * sqrt(I + 1.));
        TS2Returns[I] += 0.00000003 * sin(1.918000 + I * 0.372000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "chirp_deceleration: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "chirp_deceleration: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "chirp_deceleration: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "chirp_deceleration: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "chirp_deceleration: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "chirp_deceleration: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[199] = 2.;
    TS2Expect(TS2Evaluate() == 0., "chirp_deceleration: implausible return rejected");
    TS2Expect(TS2Quality == 0., "chirp_deceleration: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "chirp_deceleration: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "chirp_deceleration: quality restored");
}
// Case 7: positive_drift_noise; model 14 perturbation phase 1.918000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case7()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = 0.0003 + 0.0009 * sin(0.77 * I);
        TS2Returns[I] += 0.00000003 * sin(1.918000 + I * 0.372000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "positive_drift_noise: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "positive_drift_noise: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "positive_drift_noise: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "positive_drift_noise: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "positive_drift_noise: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "positive_drift_noise: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[236] = 2.;
    TS2Expect(TS2Evaluate() == 0., "positive_drift_noise: implausible return rejected");
    TS2Expect(TS2Quality == 0., "positive_drift_noise: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "positive_drift_noise: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "positive_drift_noise: quality restored");
}
// Case 8: negative_drift_noise; model 14 perturbation phase 1.918000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case8()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = -0.0003 + 0.0009 * sin(0.77 * I);
        TS2Returns[I] += 0.00000003 * sin(1.918000 + I * 0.372000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "negative_drift_noise: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "negative_drift_noise: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "negative_drift_noise: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "negative_drift_noise: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "negative_drift_noise: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "negative_drift_noise: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[17] = 2.;
    TS2Expect(TS2Evaluate() == 0., "negative_drift_noise: implausible return rejected");
    TS2Expect(TS2Quality == 0., "negative_drift_noise: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "negative_drift_noise: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "negative_drift_noise: quality restored");
}
// Case 9: mixed_frequency_drift; model 14 perturbation phase 1.918000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case9()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = 0.0002 + 0.0006 * sin(0.23 * I) + 0.0004 * cos(1.37 * I);
        TS2Returns[I] += 0.00000003 * sin(1.918000 + I * 0.372000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "mixed_frequency_drift: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "mixed_frequency_drift: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "mixed_frequency_drift: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "mixed_frequency_drift: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "mixed_frequency_drift: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "mixed_frequency_drift: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[54] = 2.;
    TS2Expect(TS2Evaluate() == 0., "mixed_frequency_drift: implausible return rejected");
    TS2Expect(TS2Quality == 0., "mixed_frequency_drift: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "mixed_frequency_drift: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "mixed_frequency_drift: quality restored");
}
// Case 10: alternating_sign; model 14 perturbation phase 1.918000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case10()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = ifelse(I % 2 == 0, 0.001, -0.001);
        TS2Returns[I] += 0.00000003 * sin(1.918000 + I * 0.372000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "alternating_sign: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "alternating_sign: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "alternating_sign: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "alternating_sign: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "alternating_sign: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "alternating_sign: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[91] = 2.;
    TS2Expect(TS2Evaluate() == 0., "alternating_sign: implausible return rejected");
    TS2Expect(TS2Quality == 0., "alternating_sign: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "alternating_sign: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "alternating_sign: quality restored");
}
// Case 11: three_bar_blocks; model 14 perturbation phase 1.918000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case11()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = ifelse(I % 6 < 3, 0.001, -0.001);
        TS2Returns[I] += 0.00000003 * sin(1.918000 + I * 0.372000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "three_bar_blocks: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "three_bar_blocks: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "three_bar_blocks: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "three_bar_blocks: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "three_bar_blocks: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "three_bar_blocks: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[128] = 2.;
    TS2Expect(TS2Evaluate() == 0., "three_bar_blocks: implausible return rejected");
    TS2Expect(TS2Quality == 0., "three_bar_blocks: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "three_bar_blocks: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "three_bar_blocks: quality restored");
}
// Case 12: five_bar_blocks; model 14 perturbation phase 1.918000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case12()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = ifelse(I % 10 < 5, 0.001, -0.001);
        TS2Returns[I] += 0.00000003 * sin(1.918000 + I * 0.372000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "five_bar_blocks: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "five_bar_blocks: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "five_bar_blocks: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "five_bar_blocks: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "five_bar_blocks: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "five_bar_blocks: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[165] = 2.;
    TS2Expect(TS2Evaluate() == 0., "five_bar_blocks: implausible return rejected");
    TS2Expect(TS2Quality == 0., "five_bar_blocks: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "five_bar_blocks: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "five_bar_blocks: quality restored");
}
// Case 13: one_sided_steps; model 14 perturbation phase 1.918000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case13()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = ifelse(I < 24, 0.001, 0.0001) + 0.0001 * sin(I);
        TS2Returns[I] += 0.00000003 * sin(1.918000 + I * 0.372000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "one_sided_steps: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "one_sided_steps: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "one_sided_steps: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "one_sided_steps: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "one_sided_steps: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "one_sided_steps: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[202] = 2.;
    TS2Expect(TS2Evaluate() == 0., "one_sided_steps: implausible return rejected");
    TS2Expect(TS2Quality == 0., "one_sided_steps: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "one_sided_steps: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "one_sided_steps: quality restored");
}
// Case 14: late_reversal; model 14 perturbation phase 1.918000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case14()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = ifelse(I < 12, -0.0008, 0.0005) + 0.0002 * cos(0.7 * I);
        TS2Returns[I] += 0.00000003 * sin(1.918000 + I * 0.372000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "late_reversal: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "late_reversal: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "late_reversal: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "late_reversal: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "late_reversal: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "late_reversal: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[239] = 2.;
    TS2Expect(TS2Evaluate() == 0., "late_reversal: implausible return rejected");
    TS2Expect(TS2Quality == 0., "late_reversal: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "late_reversal: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "late_reversal: quality restored");
}
// Case 15: middle_reversal; model 14 perturbation phase 1.918000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case15()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = ifelse(I < 64, 0.0006, -0.0004) + 0.0002 * sin(0.43 * I);
        TS2Returns[I] += 0.00000003 * sin(1.918000 + I * 0.372000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "middle_reversal: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "middle_reversal: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "middle_reversal: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "middle_reversal: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "middle_reversal: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "middle_reversal: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[20] = 2.;
    TS2Expect(TS2Evaluate() == 0., "middle_reversal: implausible return rejected");
    TS2Expect(TS2Quality == 0., "middle_reversal: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "middle_reversal: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "middle_reversal: quality restored");
}
// Case 16: old_reversal; model 14 perturbation phase 1.918000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case16()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = ifelse(I < 160, 0.0004, -0.0007) + 0.0001 * cos(0.91 * I);
        TS2Returns[I] += 0.00000003 * sin(1.918000 + I * 0.372000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "old_reversal: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "old_reversal: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "old_reversal: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "old_reversal: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "old_reversal: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "old_reversal: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[57] = 2.;
    TS2Expect(TS2Evaluate() == 0., "old_reversal: implausible return rejected");
    TS2Expect(TS2Quality == 0., "old_reversal: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "old_reversal: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "old_reversal: quality restored");
}
// Case 17: volatility_expansion; model 14 perturbation phase 1.918000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case17()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = (0.0002 + 0.001 * exp(-0.015 * I)) * sin(0.81 * I);
        TS2Returns[I] += 0.00000003 * sin(1.918000 + I * 0.372000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "volatility_expansion: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "volatility_expansion: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "volatility_expansion: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "volatility_expansion: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "volatility_expansion: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "volatility_expansion: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[94] = 2.;
    TS2Expect(TS2Evaluate() == 0., "volatility_expansion: implausible return rejected");
    TS2Expect(TS2Quality == 0., "volatility_expansion: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "volatility_expansion: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "volatility_expansion: quality restored");
}
// Case 18: volatility_contraction; model 14 perturbation phase 1.918000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case18()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = (0.0002 + 0.000004 * I) * sin(0.81 * I);
        TS2Returns[I] += 0.00000003 * sin(1.918000 + I * 0.372000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "volatility_contraction: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "volatility_contraction: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "volatility_contraction: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "volatility_contraction: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "volatility_contraction: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "volatility_contraction: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[131] = 2.;
    TS2Expect(TS2Evaluate() == 0., "volatility_contraction: implausible return rejected");
    TS2Expect(TS2Quality == 0., "volatility_contraction: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "volatility_contraction: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "volatility_contraction: quality restored");
}
// Case 19: isolated_recent_up; model 14 perturbation phase 1.918000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case19()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = ifelse(I == 3, 0.008, 0.0002 * sin(0.61 * I));
        TS2Returns[I] += 0.00000003 * sin(1.918000 + I * 0.372000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "isolated_recent_up: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "isolated_recent_up: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "isolated_recent_up: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "isolated_recent_up: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "isolated_recent_up: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "isolated_recent_up: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[168] = 2.;
    TS2Expect(TS2Evaluate() == 0., "isolated_recent_up: implausible return rejected");
    TS2Expect(TS2Quality == 0., "isolated_recent_up: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "isolated_recent_up: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "isolated_recent_up: quality restored");
}
// Case 20: isolated_recent_down; model 14 perturbation phase 1.918000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case20()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = ifelse(I == 3, -0.008, 0.0002 * sin(0.61 * I));
        TS2Returns[I] += 0.00000003 * sin(1.918000 + I * 0.372000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "isolated_recent_down: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "isolated_recent_down: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "isolated_recent_down: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "isolated_recent_down: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "isolated_recent_down: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "isolated_recent_down: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[205] = 2.;
    TS2Expect(TS2Evaluate() == 0., "isolated_recent_down: implausible return rejected");
    TS2Expect(TS2Quality == 0., "isolated_recent_down: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "isolated_recent_down: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "isolated_recent_down: quality restored");
}
// Case 21: paired_opposite_shocks; model 14 perturbation phase 1.918000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case21()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = ifelse(I == 7, 0.006, ifelse(I == 11, -0.006, 0.0001 * cos(I)));
        TS2Returns[I] += 0.00000003 * sin(1.918000 + I * 0.372000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "paired_opposite_shocks: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "paired_opposite_shocks: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "paired_opposite_shocks: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "paired_opposite_shocks: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "paired_opposite_shocks: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "paired_opposite_shocks: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[242] = 2.;
    TS2Expect(TS2Evaluate() == 0., "paired_opposite_shocks: implausible return rejected");
    TS2Expect(TS2Quality == 0., "paired_opposite_shocks: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "paired_opposite_shocks: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "paired_opposite_shocks: quality restored");
}
// Case 22: paired_same_shocks; model 14 perturbation phase 1.918000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case22()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = ifelse(I == 7 || I == 11, 0.006, 0.0001 * cos(I));
        TS2Returns[I] += 0.00000003 * sin(1.918000 + I * 0.372000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "paired_same_shocks: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "paired_same_shocks: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "paired_same_shocks: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "paired_same_shocks: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "paired_same_shocks: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "paired_same_shocks: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[23] = 2.;
    TS2Expect(TS2Evaluate() == 0., "paired_same_shocks: implausible return rejected");
    TS2Expect(TS2Quality == 0., "paired_same_shocks: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "paired_same_shocks: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "paired_same_shocks: quality restored");
}

ZorroGPT - https://bit.ly/3Gbsm4S