ZorroGPT

Gamestudio Links

Zorro Links

Newest Posts

Zorro plugin for Hyperliquid.xyz
by mayarik. 10/24/26 09:14

ZorroGPT
by TipmyPip. 10/24/26 01:54

Tradestation missing in table of contents
by AndrewAMD. 10/23/26 14:35

Zorro not reconnecting to IB gateway after restart
by opm. 10/23/26 04:24

No connection to MT4
by JeyKey II. 10/22/26 15:33

Missing PnL files in zOpen child processes
by jcl. 10/22/26 10:25

Zorro tutorial ideas?
by mistery. 10/21/26 05:28

Avoid "log\ - delete old files" message
by Martin_HH. 10/20/26 07:23

AUM Magazine

Latest Screens

Who's Online Now

2 registered members (TipmyPip, mayarik), 7,449 guests, and 1 spider.

Key: Admin, Global Mod, Mod

Newest Members

JimSimons, julienp, julienper, KelleyAbbey, Yopachi
19246 Registered Users

Print Thread

Rate Thread

DetrendedScaling [Re: TipmyPip] #489737
10 hours ago 10 hours ago

Joined: Sep 2017
Posts: 355

TipmyPip

OP
Senior Member

TipmyPip

OP
Senior Member

Joined: Sep 2017
Posts: 355

Detrended Fluctuation Scaling

This strategy studies how detrended fluctuations grow as the observation scale increases. Its directional decision is conditional on a persistence estimate, rather than on a principal component, a fitted equilibrium spread, or a volatility forecast curve. The underlying market hypothesis is that agreement between short and longer drift is more interesting when the integrated return profile exhibits persistent scaling. This is a measurement of finite-sample behavior, not a declaration that the market follows an exact fractional stochastic process.

The calculation begins with 240 completed returns. After subtracting their overall mean, the observations are accumulated in chronological order: profile[t] = sum(x[j]-mean, j=0..t). The model then inspects box lengths 8, 12, 18, 27, 40, and 60. For each length s, it partitions the available profile into complete, nonoverlapping boxes. Any unused remainder is omitted for that scale. Within every box it independently estimates a straight line fit[j] = intercept + slope*j by ordinary least squares. This local detrending matters because a simple aggregate variance would mix deterministic drift with fluctuations.

For each scale, the model obtains F[s] = sqrt(sum((profile-fit)^2)/number_of_used_points). It then regresses log(F[s]) on log(s). The slope of that six-point regression is the scaling exponent alpha. The corresponding residual sum of squares measures whether a single straight relationship in log-scale space is a reasonable summary. Degenerate fluctuation magnitudes cause an immediate abstention instead of taking a logarithm of zero. In particular, a perfectly constant return sequence is not treated as conclusive evidence of stochastic long memory.

Direction is estimated separately from the scaling measurement. The recent signed averages are short = sum(r[0..11])/12 and long = sum(r[0..59])/60. Their product must be positive. The model also requires alpha > 0.55, and quality increases with alpha - 0.5 while decreasing with the log-scale regression error. The signed forecast numerator is (short + long)*sqrt(12). Dividing it by a root-mean-square expression produces an edge bounded between minus one and one. The shared quality and edge thresholds still apply, and the maximum holding duration is twenty-four hourly bars.

This method is materially different from changing a moving-average period: the multiscale residual geometry determines whether directional drift is even eligible. However, deterministic oscillations, structural breaks, finite-window bias, and heavy-tailed observations can all distort the exponent. Adjacent scales are also dependent because they reuse the same underlying returns. Neither the exponent nor the quality field is a calibrated probability of a winning trade. Synthetic cases exercise trends, reversals, changing amplitudes, shocks, and small-return conditions, but historical walk-forward testing and transaction-cost sensitivity remain necessary before any deployment decision.

Code

// TS12_DetrendedScaling: Detrended fluctuation scaling.
// 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: detrended fluctuation exponent.
// Quality heuristic: Persistence above one half and log-scale fit residual.
// Limitation: Finite samples and deterministic oscillations can resemble long memory; this is not proof of a Hurst process.
// 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 = "TS12";
string TS2TestLog = "Log/TS12_DetrendedScaling_test.txt";
int TS2Holding = 24;
// 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 (Value != 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 (TS2Returns[Index] != 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 (TS2Raw != TS2Raw || abs(TS2Raw) > 1.e12)
    {
        TS2Quality = 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
// Integrated demeaned return profile; detrend separately inside each box.
// The scaling exponent selects persistence, while signed drift sets direction.
var TS2Model()
{
    int Sizes[6] = {8, 12, 18, 27, 40, 60};
    var Profile[240], Fluctuation[6];
    var Mean, Sum, XSum, XXSum, YSum, XYSum, Slope, Intercept;
    var Residual, Error, XS, YS, XX, XY, Exponent, FitError;
    var ShortDrift, LongDrift, Variation, Agreement, Signal;
    int Scale, Box, Offset, Width, Count, Position;
    Mean = 0.;
    for (Position = 0; Position < 240; Position++)
        Mean += TS2Returns[Position] / 240.;
    Sum = 0.;
    for (Position = 0; Position < 240; Position++)
    {
        Sum += TS2Returns[239 - Position] - Mean;
        Profile[Position] = Sum;
    }
    for (Scale = 0; Scale < 6; Scale++)
    {
        Width = Sizes[Scale];
        Count = 240 / Width;
        Error = 0.;
        XSum = Width * (Width - 1.) / 2.;
        XXSum = Width * (Width - 1.) * (2. * Width - 1.) / 6.;
        for (Box = 0; Box < Count; Box++)
        {
            YSum = 0.;
            XYSum = 0.;
            for (Offset = 0; Offset < Width; Offset++)
            {
                YSum += Profile[Box * Width + Offset];
                XYSum += Offset * Profile[Box * Width + Offset];
            }
            Slope = (Width * XYSum - XSum * YSum) / (Width * XXSum - XSum * XSum);
            Intercept = (YSum - Slope * XSum) / Width;
            for (Offset = 0; Offset < Width; Offset++)
            {
                Residual = Profile[Box * Width + Offset] - Intercept - Slope * Offset;
                Error += Residual * Residual;
            }
        }
        Fluctuation[Scale] = sqrt(Error / (Count * Width));
    }
    XS = 0.; YS = 0.; XX = 0.; XY = 0.;
    for (Scale = 0; Scale < 6; Scale++)
    {
        if (Fluctuation[Scale] < 1.e-16)
            return 0.;
        XS += log(Sizes[Scale]);
        YS += log(Fluctuation[Scale]);
        XX += pow(log(Sizes[Scale]), 2.);
        XY += log(Sizes[Scale]) * log(Fluctuation[Scale]);
    }
    Exponent = (6. * XY - XS * YS) / (6. * XX - XS * XS);
    Intercept = (YS - Exponent * XS) / 6.;
    FitError = 0.;
    for (Scale = 0; Scale < 6; Scale++)
        FitError += pow(log(Fluctuation[Scale]) - Intercept - Exponent * log(Sizes[Scale]), 2.);
    ShortDrift = 0.; LongDrift = 0.; Variation = 0.;
    for (Position = 0; Position < 60; Position++)
    {
        LongDrift += TS2Returns[Position] / 60.;
        Variation += TS2Returns[Position] * TS2Returns[Position] / 60.;
        if (Position < 12)
            ShortDrift += TS2Returns[Position] / 12.;
    }
    Agreement = ShortDrift * LongDrift;
    TS2Statistic = Exponent;
    TS2Quality = max(0., min(1., (Exponent - 0.5) * 2.)) / (1. + FitError);
    if (Agreement <= 0. || Exponent <= 0.55)
        return 0.;
    Signal = (ShortDrift + LongDrift) * sqrt(12.);
    return Signal / sqrt(Variation + Signal * Signal + 1.e-24);
}
// END ANALYTICAL MODEL
// 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");
}
// Case 1: slow_sine; model 12 perturbation phase 1.644000.
// 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.644000 + I * 0.346000);
        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[12] = 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 12 perturbation phase 1.644000.
// 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.644000 + I * 0.346000);
        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[49] = 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 12 perturbation phase 1.644000.
// 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.644000 + I * 0.346000);
        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[86] = 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 12 perturbation phase 1.644000.
// 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.644000 + I * 0.346000);
        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[123] = 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 12 perturbation phase 1.644000.
// 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.644000 + I * 0.346000);
        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[160] = 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 12 perturbation phase 1.644000.
// 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.644000 + I * 0.346000);
        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[197] = 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 12 perturbation phase 1.644000.
// 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.644000 + I * 0.346000);
        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[234] = 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 12 perturbation phase 1.644000.
// 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.644000 + I * 0.346000);
        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[15] = 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 12 perturbation phase 1.644000.
// 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.644000 + I * 0.346000);
        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[52] = 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 12 perturbation phase 1.644000.
// 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.644000 + I * 0.346000);
        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[89] = 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 12 perturbation phase 1.644000.
// 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.644000 + I * 0.346000);
        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[126] = 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 12 perturbation phase 1.644000.
// 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.644000 + I * 0.346000);
        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[163] = 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 12 perturbation phase 1.644000.
// 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.644000 + I * 0.346000);
        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[200] = 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 12 perturbation phase 1.644000.
// 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.644000 + I * 0.346000);
        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[237] = 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 12 perturbation phase 1.644000.
// 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.644000 + I * 0.346000);
        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[18] = 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 12 perturbation phase 1.644000.
// 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.644000 + I * 0.346000);
        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[55] = 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 12 perturbation phase 1.644000.
// 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.644000 + I * 0.346000);
        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[92] = 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 12 perturbation phase 1.644000.
// 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.644000 + I * 0.346000);
        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[129] = 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 12 perturbation phase 1.644000.
// 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.644000 + I * 0.346000);
        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[166] = 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 12 perturbation phase 1.644000.
// 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.644000 + I * 0.346000);
        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[203] = 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 12 perturbation phase 1.644000.
// 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.644000 + I * 0.346000);
        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[240] = 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 12 perturbation phase 1.644000.
// 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.644000 + I * 0.346000);
        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[21] = 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");
}
// Case 23: old_shock; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case23()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = ifelse(I == 211, 0.012, 0.0003 * sin(0.27 * I));
        TS2Returns[I] += 0.00000003 * sin(1.644000 + I * 0.346000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "old_shock: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "old_shock: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "old_shock: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "old_shock: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "old_shock: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "old_shock: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[58] = 2.;
    TS2Expect(TS2Evaluate() == 0., "old_shock: implausible return rejected");
    TS2Expect(TS2Quality == 0., "old_shock: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "old_shock: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "old_shock: quality restored");
}
// Case 24: sparse_up_events; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case24()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = ifelse(I % 17 == 0, 0.003, -0.0001);
        TS2Returns[I] += 0.00000003 * sin(1.644000 + I * 0.346000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "sparse_up_events: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "sparse_up_events: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "sparse_up_events: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "sparse_up_events: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "sparse_up_events: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "sparse_up_events: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[95] = 2.;
    TS2Expect(TS2Evaluate() == 0., "sparse_up_events: implausible return rejected");
    TS2Expect(TS2Quality == 0., "sparse_up_events: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "sparse_up_events: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "sparse_up_events: quality restored");
}
// Case 25: sparse_down_events; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case25()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = ifelse(I % 17 == 0, -0.003, 0.0001);
        TS2Returns[I] += 0.00000003 * sin(1.644000 + I * 0.346000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "sparse_down_events: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "sparse_down_events: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "sparse_down_events: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "sparse_down_events: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "sparse_down_events: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "sparse_down_events: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[132] = 2.;
    TS2Expect(TS2Evaluate() == 0., "sparse_down_events: implausible return rejected");
    TS2Expect(TS2Quality == 0., "sparse_down_events: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "sparse_down_events: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "sparse_down_events: quality restored");
}
// Case 26: clustered_up_events; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case26()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = ifelse(I % 29 < 4, 0.002, -0.00015);
        TS2Returns[I] += 0.00000003 * sin(1.644000 + I * 0.346000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "clustered_up_events: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "clustered_up_events: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "clustered_up_events: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "clustered_up_events: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "clustered_up_events: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "clustered_up_events: directional reflection");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    TS2Returns[169] = 2.;
    TS2Expect(TS2Evaluate() == 0., "clustered_up_events: implausible return rejected");
    TS2Expect(TS2Quality == 0., "clustered_up_events: rejected sample clears quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = Snapshot[I];
    Restored = TS2Evaluate();
    TS2Expect(abs(Restored - Original) < 1.e-9, "clustered_up_events: restored input has no stale state");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "clustered_up_events: quality restored");
}
// Case 27: clustered_down_events; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case27()
{
    var Snapshot[256], Original, Repeated, Reflected, Restored;
    var InitialQuality, InitialStatistic;
    int I;
    for (I = 0; I < 256; I++)
    {
        TS2Returns[I] = ifelse(I % 29 < 4, -0.002, 0.00015);
        TS2Returns[I] += 0.00000003 * sin(1.644000 + I * 0.346000);
        Snapshot[I] = TS2Returns[I];
    }
    Original = TS2Evaluate();
    InitialQuality = TS2Quality;
    InitialStatistic = TS2Statistic;
    TS2Expect(Original == Original && abs(Original) <= 1., "clustered_down_events: finite bounded edge");
    TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "clustered_down_events: quality contract");
    TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "clustered_down_events: finite diagnostic");
    Repeated = TS2Evaluate();
    TS2Expect(abs(Repeated - Original) < 1.e-9, "clustered_down_events: deterministic evaluation");
    TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "clustered_down_events: deterministic quality");
    for (I = 0; I < 256; I++)
        TS2Returns[I] = -Snapshot[I];
    Reflected = TS2Evaluate();
    TS2Expect(abs(Reflected + Original) < 1.e-7, "clustered_down_events: directiona

Last edited by TipmyPip; 9 hours ago.

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

Entire Thread
Subject	Posted By	Posted
ZorroGPT	TipmyPip	11/19/23 11:26
Re: Zorro Trader GPT	thumper14	11/21/23 15:14
Re: Zorro Trader GPT	TipmyPip	11/22/23 05:08
Re: Zorro Trader GPT	AndrewAMD	11/22/23 12:25
Re: Zorro Trader GPT	TipmyPip	11/22/23 14:11
Re: Zorro Trader GPT	AndrewAMD	11/22/23 15:24
Re: Zorro Trader GPT	TipmyPip	11/22/23 16:53
Re: Zorro Trader GPT	NewtraderX	12/02/23 02:15
Re: Zorro Trader GPT	TipmyPip	12/02/23 06:10
Re: Zorro Trader GPT	fairtrader	12/04/23 09:16
Re: Zorro Trader GPT	TipmyPip	12/04/23 11:34
Re: Zorro Trader GPT	NewtraderX	12/10/23 20:09
Re: Zorro Trader GPT	TipmyPip	12/13/23 11:01
Re: Zorro Trader GPT	TipmyPip	12/28/23 14:22
Re: Zorro Trader GPT	scatters	02/13/24 16:24
Re: Zorro Trader GPT	TipmyPip	02/16/24 06:53
ZorroTraderGPT Update (2.6)	TipmyPip	03/06/24 09:27
Re: Zorro Trader GPT	TipmyPip	04/01/24 11:43
Re: Zorro Trader GPT	TipmyPip	04/01/24 11:53
Re: Zorro Trader GPT	TipmyPip	04/01/24 11:59
Re: Zorro Trader GPT	TipmyPip	04/01/24 12:06
Re: Zorro Trader GPT	TipmyPip	04/01/24 12:23
Re: Zorro Trader GPT	TipmyPip	04/01/24 21:39
Re: Zorro Trader GPT	Smon	04/05/24 04:51
Re: Zorro Trader GPT	TipmyPip	04/05/24 06:35
Re: Zorro Trader GPT	Smon	04/06/24 05:12
Re: Zorro Trader GPT	TipmyPip	04/27/24 13:50
Re: Zorro Trader GPT	TipmyPip	04/06/24 08:11
Re: Zorro Trader GPT	TipmyPip	07/06/24 15:23
Gaussian Channel Adaptive Strategy	TipmyPip	07/06/24 15:31
Re: Gaussian Channel Adaptive Strategy	M_D	01/13/25 01:47
Re: Gaussian Channel Adaptive Strategy	TipmyPip	01/13/25 05:33
Multi-Factor Gaussian FX Strategy	TipmyPip	07/06/24 15:56
Gaussian Bands Strategy	TipmyPip	07/06/24 17:16
Gaussian Decision Tree Hedging Strategy	TipmyPip	07/11/24 05:43
Gaussian-Enhanced Hybrid Ensemble Strategy	TipmyPip	07/20/24 05:00
Re: Gaussian-Enhanced Hybrid Ensemble Strategy	TipmyPip	07/20/24 06:46
Re: Gaussian-Enhanced Hybrid Ensemble Strategy	firecrest	10/01/24 10:42
Re: Gaussian-Enhanced Hybrid Ensemble Strategy	TipmyPip	10/04/24 19:33
Re: Gaussian-Enhanced Hybrid Ensemble Strategy	firecrest	11/07/24 07:53
Re: Gaussian-Enhanced Hybrid Ensemble Strategy	TipmyPip	11/09/24 16:42
PyTorch DRL with ZorroGPT	TipmyPip	11/09/24 16:52
DRL direct Feed from Zorro	TipmyPip	11/09/24 17:07
Multi Agent DRL with Simple Stategy	TipmyPip	11/10/24 10:36
Delta Dynamics	TipmyPip	12/24/24 18:36
Delta Cycle Dynamics	TipmyPip	12/24/24 18:40
Î£ Î¦ - Î” Îž (t), Î£ Î¦ Î” Îž (âˆ«f(Ï„)dÏ„)	TipmyPip	12/24/24 19:47
Profit Path Conundrum	TipmyPip	12/25/24 14:23
Stochastic Correlation in Currency Pairs	TipmyPip	12/25/24 15:34
PCA and Stochastic Volatility	TipmyPip	12/25/24 17:43
Re: PCA and Stochastic Volatility	vicknick	01/02/25 06:37
Re: PCA and Stochastic Volatility	TipmyPip	01/02/25 06:51
Entangled Kernel Arbitrage	TipmyPip	01/02/25 09:02
Kernel Volatility Arbitrage Enigma	TipmyPip	01/02/25 09:36
The Volatility Feedback Arbitrage	TipmyPip	01/02/25 10:10
Kernelized Profitability Arbitrage	TipmyPip	01/02/25 10:39
Recursive Kernel PCA with GNN for Profitability Optimization	TipmyPip	01/02/25 12:39
Multi-GNN Recursive Kernel PCA	TipmyPip	01/02/25 18:41
Volatility-Driven Graph Signal Strategy	TipmyPip	01/07/25 11:17
Volatility Graph Dynamics	TipmyPip	01/07/25 12:10
Synergistic Graph-PCA Arbitrage (SGPA)	TipmyPip	01/09/25 17:57
Decoding the Dynamics of Volatility Interdependencies	TipmyPip	01/09/25 18:20
Quantum Market Entanglement Problem	TipmyPip	01/09/25 18:48
Stochastic Interdependent Volatility-Adaptive Signal	TipmyPip	01/09/25 19:46
Time-Series Volatility Clustering and Adaptive Trading Signals	TipmyPip	01/09/25 20:10
The Hydra's Awakening	TipmyPip	01/25/25 14:09
Re: The Hydra's Awakening	TipmyPip	01/26/25 19:53
Re: The Hydra's Awakening	OptimusPrime	01/30/25 00:38
Re: The Hydra's Awakening	TipmyPip	01/30/25 03:51
Re: Zorro Trader GPT	TipmyPip	01/30/25 04:43
The War of Shifting Fronts	TipmyPip	01/30/25 05:31
Re: Zorro Trader GPT	OptimusPrime	01/30/25 07:12
Hard Question	TipmyPip	01/30/25 07:37
Re: Hard Question	jcl	01/30/25 10:43
The War of Shifting Fronts (Part 2)	TipmyPip	01/30/25 12:58
The War of Shifting Fronts (Part 3)	TipmyPip	01/30/25 14:13
Re: Zorro Trader GPT	TipmyPip	01/30/25 17:24
Risk Diversification in Portfolio Optimization	TipmyPip	01/31/25 10:58
The Language of Symbols	TipmyPip	02/02/25 17:56
Portfolio Dynamically Allocates Capita	TipmyPip	02/11/25 15:37
Tale of the Five Guardians	TipmyPip	02/14/25 06:58
Re: Tale of the Five Guardians	M_D	02/19/25 01:25
Multi-File Converting csv to .t6	TipmyPip	02/14/25 19:42
The Lost Computation of Zorropolis	TipmyPip	02/19/25 03:24
Graph-Enhanced Directional Trading (GEDT)	TipmyPip	02/19/25 22:48
Optimal Execution Under Incomplete Information	TipmyPip	02/20/25 09:56
Re: Zorro Trader GPT	TipmyPip	02/20/25 23:12
Markov Chain and Stochastic Asset Transitions	TipmyPip	03/16/25 12:37
VWAP Indicator for Zorro	TipmyPip	03/26/25 23:22
ZorroGPT	TipmyPip	05/23/25 09:22
Market Manipulation Index (MMI) for Zorro	TipmyPip	07/09/25 13:41
enhMMI indicator	TipmyPip	07/20/25 06:53
Re: enhanced MMI	dBc	08/06/25 17:15
Re: enhanced MMI	TipmyPip	08/08/25 18:56
multi-timeframe “Market Mode Index”	TipmyPip	08/09/25 01:33
Murrey Math Lines	TipmyPip	08/21/25 05:43
The Strategy of Spiritual Love.	TipmyPip	09/01/25 17:20
The Breach of Algorithms	TipmyPip	09/01/25 18:14
Proportional Rule-Switching Agents (PRSA)	TipmyPip	09/01/25 21:35
Gate-and-Field Adaptive Engine (GFAE)	TipmyPip	09/04/25 16:56
Gate-and-Flow Adaptive Navigator	TipmyPip	09/06/25 00:26
Regime-Responsive Graph Rewiring of Influences	TipmyPip	09/06/25 19:35
Canticle of the Rewoven Mandala	TipmyPip	09/14/25 12:15
Canticle of the Rewoven Mandala	TipmyPip	09/14/25 12:28
Consensus Gate Orchestrator	TipmyPip	09/27/25 10:02
Consensus Gate Orchestrator (continue)	TipmyPip	09/27/25 10:05
The Serpent of Skew	TipmyPip	10/12/25 13:58
Re: The Serpent of Skew	turbodom	10/20/25 20:54
Re: The Serpent of Skew	TipmyPip	10/22/25 05:51
Re: The Serpent of Skew	TipmyPip	10/23/25 21:05
Empirical Analysis of Asset Prices	TipmyPip	11/08/25 22:28
Empirical Analysis of Asset Prices (with NN)	TipmyPip	11/09/25 08:39
Re: Empirical Analysis of Asset Prices (with NN)	TipmyPip	11/10/25 11:04
SAR MOMENTUM BOT	TipmyPip	11/19/25 10:10
Adaptive Slope Trend	TipmyPip	11/29/25 08:58
RegSlope Adaptive Control Slope Trend	TipmyPip	11/29/25 09:38
Entropy Edge Learner (EEL)	TipmyPip	01/20/26 07:17
EigenGlyph Cascade	TipmyPip	01/22/26 07:08
Twin Horizon Bandit Weaver	TipmyPip	01/22/26 09:32
Fractal Bandit Compass	TipmyPip	01/22/26 12:25
TwinPulse Fractal Accord	TipmyPip	01/24/26 03:55
ScaleWeave Sentinel	TipmyPip	01/24/26 04:10
Runge–Kutta methods	TipmyPip	01/24/26 07:26
RK-382A Neural ODE	TipmyPip	01/27/26 06:01
The Stage Shuffle Cache Saver	TipmyPip	01/28/26 09:08
The Next Stage.	TipmyPip	01/28/26 09:48
The Clockwork Storm Weaver	TipmyPip	01/31/26 08:02
The Clockwork Storm Weaver (64Bit)	TipmyPip	01/31/26 09:23
The Clockwork Storm Weaver (OpenCL)	TipmyPip	01/31/26 09:49
The Clockwork Storm Weaver (CUDA)	TipmyPip	01/31/26 10:01
TorchBridge LineWorld Learner (Cuda Torch)	TipmyPip	01/31/26 17:11
The Candle Oracle Lattice	TipmyPip	02/03/26 10:19
The Candle Oracle Lattice (cont.)	TipmyPip	02/03/26 10:21
The Candle Oracle Lattice (CUDA version)	TipmyPip	02/03/26 12:58
The Candle Oracle Lattice (CUDA version cont.)	TipmyPip	02/03/26 13:02
Re: The Candle Oracle Lattice (CUDA version cont.)	qin	02/04/26 23:52
The Candle Oracle Lattice (OpenCL version)	TipmyPip	02/05/26 09:39
The Candle Oracle Lattice (OpenCL cont.)	TipmyPip	02/05/26 11:14
Wiener index W(g)	TipmyPip	02/21/26 18:06
Microstructure Networks	TipmyPip	02/21/26 18:26
Decision Making Graph Geometry	TipmyPip	02/21/26 19:15
KnotScope FX	TipmyPip	02/23/26 18:47
CrowdAverse	TipmyPip	02/23/26 18:50
RegimeAtlas	TipmyPip	02/23/26 18:53
VolSieve	TipmyPip	02/23/26 18:56
MomentumBias Nexus	TipmyPip	02/23/26 18:59
NexusWeave Compact Dominant	TipmyPip	02/23/26 19:02
HermitNet FX	TipmyPip	02/23/26 19:08
AstraRegime Nexus	TipmyPip	02/23/26 19:57
NexusVol Navigator	TipmyPip	02/23/26 19:59
GraphPulse MomentumBias	TipmyPip	02/23/26 20:01
GraphWeaver-CL (openCL)	TipmyPip	02/23/26 20:57
CrowdAverseCL (openCL)	TipmyPip	02/23/26 21:07
RegimeWeaver (OpenCL)	TipmyPip	02/23/26 21:43
AetherWeave-28 (OpenCL)	TipmyPip	02/23/26 21:49
“Atlas Momentum Mesh” (OpenCL)	TipmyPip	02/23/26 21:52
EquiPulse DualGate	TipmyPip	02/25/26 12:15
CompactClaw Atlas	TipmyPip	02/25/26 21:36
CrowdAverse Nexus v4 (RL)	TipmyPip	02/25/26 21:44
GraphForge Regime Weaver v4 (RL)	TipmyPip	02/25/26 21:51
Momentum Loom Nexus	TipmyPip	02/25/26 22:00
NebulaSwitch Matrix v4 (RL)	TipmyPip	02/25/26 22:12
Momentum Loom Conductor v5 (RL)	TipmyPip	02/25/26 22:55
CompactClaw Constellation v5 (RL)	TipmyPip	02/25/26 23:07
CrowdAverse Nexus v5 (RL)	TipmyPip	02/25/26 23:21
PrismWeave Regime Switcher v5 (RL)	TipmyPip	02/26/26 11:26
VolWeave Constellation v5 (RL)	TipmyPip	02/26/26 11:29
Compactness Crown v6 (RL)	TipmyPip	02/26/26 11:39
CrowdAverse Prism v6 (RL)	TipmyPip	02/26/26 11:42
PrismLattice Switcher v6 (RL)	TipmyPip	02/26/26 11:47
VolSynapse Constellation v6 (RL)	TipmyPip	02/26/26 11:50
Momentum Loom Nexus v6 (RL)	TipmyPip	02/26/26 11:53
CompactCrown Matrix v7 (RL)	TipmyPip	02/26/26 11:56
CrowdAverse Prism v7 (RL)	TipmyPip	02/26/26 11:59
PrismWeave Regime Switcher v7 (RL)	TipmyPip	02/26/26 12:02
VolEdge Nexus v7 (RL)	TipmyPip	02/26/26 12:05
Momentum Loom Atlas v7 (RL)	TipmyPip	02/26/26 12:08
CompactPulse Constellation v8 (RL)	TipmyPip	02/26/26 12:14
CompactCrown Nexus v9 (RL)	TipmyPip	02/26/26 12:17
CrowdAverse Prism Nine v9 (RL)	TipmyPip	02/26/26 16:13
PrismWeave Regime Switcher v9 (RL)	TipmyPip	02/26/26 16:20
VolNet Sentinel Nine v9 (RL)	TipmyPip	02/26/26 16:25
PrismWeave Momentum Atlas v9 (RL)	TipmyPip	02/26/26 16:29
CompactCrown Navigator v10 (RL)	TipmyPip	02/26/26 16:34
CrowdAverse Nexus v10 (RL)	TipmyPip	02/26/26 16:37
PrismSwitch Nexus v10 (RL)	TipmyPip	02/26/26 16:43
VolMesh Sentinel v10 (RL)	TipmyPip	02/26/26 16:59
Momentum Weave Nexus v10 (RL)	TipmyPip	02/26/26 17:02
CompactClaw Nexus v11 (RL)	TipmyPip	02/26/26 17:06
CrowdAverse Lattice Engine	TipmyPip	02/26/26 17:11
Re: CrowdAverse Lattice Engine	TipmyPip	02/26/26 17:55
FractalViewport Conductor	TipmyPip	02/26/26 21:35
OrchidSwitch Nexus v11 (RL)	TipmyPip	02/27/26 13:15
VolCorr Atlas v.11 (RL)	TipmyPip	02/27/26 16:12
Momentum Weave Conductor v.11 (RL)	TipmyPip	02/27/26 16:22
NeuroWeave CompactNet v.12 (RL)	TipmyPip	02/27/26 16:31
CrowdAverse Neural Conductor v.12 (RL)	TipmyPip	02/27/26 16:40
Outperformance	TipmyPip	02/27/26 22:06
NeuroGraph Regime Compass v12 (RL)	TipmyPip	03/01/26 16:32
NeuroWeave VolAtlas v12 (RL)	TipmyPip	03/01/26 16:36
NeuroLattice Momentum Engine v12 (RL)	TipmyPip	03/01/26 16:40
Neural Prism Renderer	TipmyPip	03/02/26 16:21
TorchBridge Pixel Loom	TipmyPip	03/02/26 16:55
Stochastic TorchCanvas Bridge	TipmyPip	03/02/26 18:02
NeuroWeave Render Bridge	TipmyPip	03/02/26 18:13
CompactDominant Atlas v13 (RL)	TipmyPip	03/05/26 01:56
CompactDominant Atlas v13 (RL) cont.	TipmyPip	03/05/26 02:40
CrowdAverse Nexus Engine v13 (RL)	TipmyPip	03/05/26 02:49
CrowdAverse Nexus Engine v13 (RL) cont.	TipmyPip	03/05/26 02:58
The Stochastic Prism Engine v5	TipmyPip	03/06/26 07:18
Stable Archetype Library	TipmyPip	03/08/26 18:50
Data Science Courses.	TipmyPip	03/20/26 05:25
The Cartography of Shifting Fires	TipmyPip	03/20/26 07:00
Janus-12 Aegis	TipmyPip	03/28/26 14:01
Core Stability Phase (GPURL)	TipmyPip	04/03/26 16:57
Re: Core Stability Phase (GPURL)	Grant	04/04/26 14:31
Re: Core Stability Phase (GPURL)	TipmyPip	04/04/26 14:59
Re: Core Stability Phase (GPURL)	Grant	04/05/26 09:36
Re: Core Stability Phase (GPURL)	TipmyPip	04/05/26 10:06
Re: Core Stability Phase (GPURL)	TipmyPip	04/05/26 03:57
The Cartographer of Compact Currents	TipmyPip	04/08/26 17:07
The Cartographer of Compact Currents (cont.)	TipmyPip	04/08/26 17:08
Live in your Account	TipmyPip	04/23/26 14:23
Aether Volatility Compass	TipmyPip	04/25/26 16:09
AutoARIMA	TipmyPip	05/08/26 11:14
AutoArima Optimized	TipmyPip	05/09/26 11:58
ARIMA Package for Zorro	TipmyPip	05/17/26 12:08
Re: ARIMA Package for Zorro	qin	05/22/26 07:55
Re: ARIMA Package for Zorro	TipmyPip	05/22/26 17:48
Re: ARIMA Package for Zorro	TipmyPip	05/27/26 19:54
Re: ARIMA Package for Zorro	Grant	05/23/26 20:53
ARIMA Package for Zorro (64bit)	TipmyPip	05/27/26 22:41
EUR/USD SMA + ARIMA forecast	TipmyPip	05/28/26 01:43
Arima Indicator Matrix (v1)	TipmyPip	06/06/26 12:00
Arima Indicator Matrix (v2)	TipmyPip	06/06/26 12:34
Arima Indicator Matrix (v3)	TipmyPip	06/06/26 12:36
Arima Physics Time Series	TipmyPip	06/10/26 13:07
Physics Time Series Simulator v2	TipmyPip	06/24/26 18:31
CrowdShield FX	TipmyPip	07/21/26 17:52
CrowdShield FX (cont.)	TipmyPip	07/21/26 17:54
Adaptive Currency Network Regime Selector	TipmyPip	07/30/26 00:34
Re: SevenBandVWAP TickReactive HFT	OptimusPrime	08/15/26 23:39
Re: SevenBandVWAP TickReactive HFT	TipmyPip	08/17/26 19:28
Re: NonlinearPriceTimeManifold	OptimusPrime	08/26/26 16:57
Re: NonlinearPriceTimeManifold	TipmyPip	08/26/26 19:05
Re: NonlinearPriceTimeManifold v.1.01	AndrewAMD	08/27/26 15:28
Adaptive Currency Network Regime Selector (cont.)	TipmyPip	07/30/26 00:36
SevenBandVWAP TickReactive HFT	TipmyPip	07/31/26 22:56
NonlinearPriceTimeManifold	TipmyPip	08/22/26 08:44
NonlinearPriceTimeManifold v.1.01	TipmyPip	08/26/26 22:38
NonlinearPriceTimeManifold v.1.02	TipmyPip	08/29/26 06:56
BogieNN v 0.01	TipmyPip	09/09/26 11:57
BogieNN v0.02	TipmyPip	09/09/26 12:09
BogieNN v0.03	TipmyPip	09/09/26 12:20
BogieNN v0.04	TipmyPip	09/09/26 12:57
BogieNN v0.05	TipmyPip	09/09/26 12:58
BogieNN v0.06 GPU Torch	TipmyPip	09/09/26 13:36
BogieNN v0.07 Direct CUDA model	TipmyPip	09/09/26 13:58
BogieNN v0.08 Dual GNN on CUDA GPU	TipmyPip	09/09/26 14:35
BogieNN v0.07 DualTF MetaTransformer	TipmyPip	10/06/26 05:32
Order Book Fuzzy Strangle	TipmyPip	10/13/26 17:08
Markov Rulebook v.01	TipmyPip	10/15/26 08:28
Term Structure Covariation Strategy	TipmyPip	10/22/26 16:52
Covariance PCA	TipmyPip	Yesterday at 06:17
OU Horizon Spread	TipmyPip	Yesterday at 06:18
Kalman Curve	TipmyPip	Yesterday at 06:20
Haar Energy	TipmyPip	Yesterday at 06:22
Bipower Jump Fade	TipmyPip	Yesterday at 06:23
Covariance CUSUM	TipmyPip	Yesterday at 09:02
GARCH Forecast Curve	TipmyPip	Yesterday at 09:03
Hidden Markov Curve	TipmyPip	Yesterday at 09:05
Entropy Analogues	TipmyPip	Yesterday at 09:06
Robust Quantile Curve	TipmyPip	Yesterday at 09:08
Harmonic Phase Forecast	TipmyPip	10 hours ago
Harmonic Phase Forecast (cont.)	TipmyPip	10 hours ago
DetrendedScaling	TipmyPip	10 hours ago
DetrendedScaling (cont.)	TipmyPip	10 hours ago

Moderated by Petra