|
1 registered members (TipmyPip),
5,885
guests, and 1
spider. |
|
Key:
Admin,
Global Mod,
Mod
|
|
|
Hidden Markov Curve
[Re: TipmyPip]
#489731
Yesterday at 09:05
Yesterday at 09:05
|
Joined: Sep 2017
Posts: 355
TipmyPip
OP
Senior Member
|
OP
Senior Member
Joined: Sep 2017
Posts: 355
|
Hidden Markov Curve — The Three Weather Systems Picture the market as moving among three weather systems: an upward drifting environment, a downward drifting environment, and a quieter neutral environment. The weather cannot be observed directly. Instead, the program sees short and longer horizon returns, much as a forecaster sees temperature and wind readings while trying to infer the larger atmospheric state. Each weather system has an assumed pattern of observations and an assumed tendency to persist. The program stores transition preferences describing how likely a state is to remain in place or move to another state. It also stores observation profiles describing the return behavior expected under each environment. These settings are fixed priors and emission assumptions, not a fully fitted hidden Markov model. An older calibration period supplies a return scale. The program then replays a more recent sequence from old observations toward the newest completed bar. At each step, it first predicts the distribution of possible weather systems using the transition preferences. It next compares the observed return pair with the observation profile of every state. The resulting state weights are normalized into a new posterior distribution. A surprising observation may weaken the previously favored state, but the persistence assumptions prevent every small fluctuation from instantly replacing the entire weather forecast. The process combines continuity with new evidence rather than treating either as sufficient alone. A buying decision requires a strong posterior preference for the upward environment. A strong preference for the downward environment supports selling. If the neutral environment dominates, or if the evidence remains divided, the program avoids opening a directional position. Existing positions can be closed when support for their corresponding directional state falls below a lower retention threshold. Model diagnostics report posterior uncertainty, a projected future probability of the upward state, and uncertainty associated with possible transitions. These measures describe the internal state distribution. They can help distinguish a confident directional classification from a market that is moving ambiguously among competing interpretations. Price stops, profit targets, limited position size, and a maximum lifetime remain active because a confident classification is not equivalent to a reliable profit forecast. The short and longer return observations overlap, so the simplified emission treatment does not represent every statistical dependency. The weather analogy must therefore remain conditional. The market may develop environments that the three predefined states do not represent. Reported posterior weights are probabilities inside the assumed model, not independently established real world probabilities. Calibration, alternative state definitions, transaction costs, and genuinely unseen historical periods must be examined before these classifications can support strong practical conclusions. // Independent model 08: three-state Bayesian forward filter on return horizons.
#include <default.c>
var HMPrice[110];
var HMProbability[3];
var HMTransition[9] = {0.94, 0.03, 0.03, 0.03, 0.94, 0.03, 0.03, 0.03, 0.94};
var HMMean[3] = {1., -1., 0.};
var HMVariance[3] = {0.75, 0.75, 0.2};
int HMForwardInference()
{
int T, State, From;
var Sigma, R, LongObservation, ShortObservation, Predicted, Error;
var Evidence, Total;
var Updated[3];
for (State = 0; State < 3; State++)
{
HMProbability[State] = 1. / 3.;
}
for (T = 0; T < 110; T++)
{
if (!(HMPrice[T] > 0.))
{
return 0;
}
}
Sigma = 0.;
for (T = 81; T <= 100; T++)
{
R = log(HMPrice[T] / HMPrice[T + 1]);
Sigma += R * R / 20.;
}
if (Sigma < 1.e-20)
{
return 0;
}
Sigma = sqrt(Sigma);
// Fixed emissions and transition priors; no fitted HMM or hindsight labels.
for (T = 80; T >= 0; T--)
{
ShortObservation = log(HMPrice[T] / HMPrice[T + 1]) / Sigma;
LongObservation = log(HMPrice[T] / HMPrice[T + 4]) / (4. * Sigma);
Total = 0.;
for (State = 0; State < 3; State++)
{
Predicted = 0.;
for (From = 0; From < 3; From++)
{
Predicted += HMProbability[From] * HMTransition[From * 3 + State];
}
Error = (ShortObservation - HMMean[State]) * (ShortObservation - HMMean[State]);
Error += (LongObservation - HMMean[State]) * (LongObservation - HMMean[State]);
Evidence = exp(max(-80., -Error / (2. * HMVariance[State]))) / HMVariance[State];
Updated[State] = Predicted * Evidence;
Total += Updated[State];
}
if (Total <= 1.e-100)
{
return 0;
}
for (State = 0; State < 3; State++)
{
HMProbability[State] = Updated[State] / Total;
}
}
if (HMProbability[0] > 0.85)
{
return 1;
}
if (HMProbability[1] > 0.85)
{
return -1;
}
return 0;
}
void HMCheckPosterior()
{
int T, Problems;
var Sum;
Problems = 0;
for (T = 0; T < 110; T++)
{
HMPrice[T] = 1.;
}
if (HMForwardInference() != 0)
{
Problems++;
}
for (T = 0; T < 110; T++)
{
HMPrice[T] = exp(-0.001 * T);
}
if (HMForwardInference() != 1)
{
Problems++;
}
Sum = HMProbability[0] + HMProbability[1] + HMProbability[2];
if (abs(Sum - 1.) > 1.e-6)
{
Problems++;
}
for (T = 0; T < 110; T++)
{
HMPrice[T] = 1. / HMPrice[T];
}
if (HMForwardInference() != -1)
{
Problems++;
}
file_write("Log/TS08_HiddenMarkovCurve_test.txt", strf("4 checks; %d failures\n", Problems), 0);
}
var HMPosteriorEntropy()
{
int State;
var H;
H = 0.;
for (State = 0; State < 3; State++)
{
if (HMProbability[State] > 1.e-20)
{
H -= HMProbability[State] * log(HMProbability[State]) / log(3.);
}
}
return H;
}
var HMFutureBullProbability(int Steps)
{
int Step, From, To;
var P[3];
var Next[3];
if (Steps < 0 || Steps > 64)
{
return 0.;
}
for (From = 0; From < 3; From++)
{
P[From] = HMProbability[From];
}
for (Step = 0; Step < Steps; Step++)
{
for (To = 0; To < 3; To++)
{
Next[To] = 0.;
for (From = 0; From < 3; From++)
{
Next[To] += P[From] * HMTransition[From * 3 + To];
}
}
for (To = 0; To < 3; To++)
{
P[To] = Next[To];
}
}
return P[0];
}
var HMTransitionUncertainty()
{
int S, T;
var Result, P;
Result = 0.;
for (S = 0; S < 3; S++)
{
for (T = 0; T < 3; T++)
{
P = HMTransition[S * 3 + T];
if (P > 0.)
{
Result -= HMProbability[S] * P * log(P);
}
}
}
return Result;
}
void HMResearchDiagnostics()
{
printf("\nHMM bull %.6g; bear %.6g; neutral %.6g", HMProbability[0], HMProbability[1],
HMProbability[2]);
printf("\nHMM entropy %.6g; bull4 %.6g", HMPosteriorEntropy(), HMFutureBullProbability(4));
printf("\nHMM transition uncertainty %.6g", HMTransitionUncertainty());
}
// ============================================================================
// EXTENDED REGRESSION SUITE: deterministic properties over market regimes
// These functions run ONLY under STX_SELFTEST; they never place orders.
// ============================================================================
int HMExtendedCount = 0;
int HMExtendedFailures = 0;
void HMExpect(int Passed, string Description)
{
HMExtendedCount++;
if (!Passed)
{
HMExtendedFailures++;
file_append("Log/TS08_HiddenMarkovCurve_extended.txt", strf("FAIL: %s\n", Description));
}
}
void HMCase_quiet_cycle()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1.0 * exp(0.0005 * sin(0.17 * K));
}
Original = HMForwardInference();
HMExpect(Original >= -1 && Original <= 1, "quiet_cycle: bounded direction");
Again = HMForwardInference();
HMExpect(Again == Original, "quiet_cycle: repeatable estimate");
for (K = 0; K < 110; K++)
{
HMPrice[K] *= 7.;
}
Scaled = HMForwardInference();
HMExpect(Scaled == Original, "quiet_cycle: price-unit invariance");
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1. / HMPrice[K];
}
Reflected = HMForwardInference();
HMExpect(Reflected == -Original, "quiet_cycle: directional reflection");
HMPrice[55] = 0.;
HMExpect(HMForwardInference() == 0, "quiet_cycle: missing price rejected");
}
void HMCase_mixed_cycles()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1.0 * exp(0.003 * sin(0.23 * K) + 0.0007 * cos(0.81 * K));
}
Original = HMForwardInference();
HMExpect(Original >= -1 && Original <= 1, "mixed_cycles: bounded direction");
Again = HMForwardInference();
HMExpect(Again == Original, "mixed_cycles: repeatable estimate");
for (K = 0; K < 110; K++)
{
HMPrice[K] *= 7.;
}
Scaled = HMForwardInference();
HMExpect(Scaled == Original, "mixed_cycles: price-unit invariance");
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1. / HMPrice[K];
}
Reflected = HMForwardInference();
HMExpect(Reflected == -Original, "mixed_cycles: directional reflection");
HMPrice[55] = 0.;
HMExpect(HMForwardInference() == 0, "mixed_cycles: missing price rejected");
}
void HMCase_persistent_upward()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1.0 * exp(-0.001 * K + 0.0001 * sin(0.53 * K));
}
Original = HMForwardInference();
HMExpect(Original >= -1 && Original <= 1, "persistent_upward: bounded direction");
Again = HMForwardInference();
HMExpect(Again == Original, "persistent_upward: repeatable estimate");
for (K = 0; K < 110; K++)
{
HMPrice[K] *= 7.;
}
Scaled = HMForwardInference();
HMExpect(Scaled == Original, "persistent_upward: price-unit invariance");
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1. / HMPrice[K];
}
Reflected = HMForwardInference();
HMExpect(Reflected == -Original, "persistent_upward: directional reflection");
HMPrice[55] = 0.;
HMExpect(HMForwardInference() == 0, "persistent_upward: missing price rejected");
}
void HMCase_persistent_downward()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1.0 * exp(0.001 * K + 0.0001 * cos(0.47 * K));
}
Original = HMForwardInference();
HMExpect(Original >= -1 && Original <= 1, "persistent_downward: bounded direction");
Again = HMForwardInference();
HMExpect(Again == Original, "persistent_downward: repeatable estimate");
for (K = 0; K < 110; K++)
{
HMPrice[K] *= 7.;
}
Scaled = HMForwardInference();
HMExpect(Scaled == Original, "persistent_downward: price-unit invariance");
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1. / HMPrice[K];
}
Reflected = HMForwardInference();
HMExpect(Reflected == -Original, "persistent_downward: directional reflection");
HMPrice[55] = 0.;
HMExpect(HMForwardInference() == 0, "persistent_downward: missing price rejected");
}
void HMCase_slow_curve()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1.0 * exp(0.004 * cos(0.08 * K) + 0.0002 * sin(0.7 * K));
}
Original = HMForwardInference();
HMExpect(Original >= -1 && Original <= 1, "slow_curve: bounded direction");
Again = HMForwardInference();
HMExpect(Again == Original, "slow_curve: repeatable estimate");
for (K = 0; K < 110; K++)
{
HMPrice[K] *= 7.;
}
Scaled = HMForwardInference();
HMExpect(Scaled == Original, "slow_curve: price-unit invariance");
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1. / HMPrice[K];
}
Reflected = HMForwardInference();
HMExpect(Reflected == -Original, "slow_curve: directional reflection");
HMPrice[55] = 0.;
HMExpect(HMForwardInference() == 0, "slow_curve: missing price rejected");
}
void HMCase_rough_curve()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1.0 * exp(0.001 * sin(1.7 * K) + 0.0005 * cos(2.3 * K));
}
Original = HMForwardInference();
HMExpect(Original >= -1 && Original <= 1, "rough_curve: bounded direction");
Again = HMForwardInference();
HMExpect(Again == Original, "rough_curve: repeatable estimate");
for (K = 0; K < 110; K++)
{
HMPrice[K] *= 7.;
}
Scaled = HMForwardInference();
HMExpect(Scaled == Original, "rough_curve: price-unit invariance");
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1. / HMPrice[K];
}
Reflected = HMForwardInference();
HMExpect(Reflected == -Original, "rough_curve: directional reflection");
HMPrice[55] = 0.;
HMExpect(HMForwardInference() == 0, "rough_curve: missing price rejected");
}
void HMCase_accelerating_path()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1.0 * exp(-0.0001 * K - 0.000002 * K * K + 0.0002 * sin(0.41 * K));
}
Original = HMForwardInference();
HMExpect(Original >= -1 && Original <= 1, "accelerating_path: bounded direction");
Again = HMForwardInference();
HMExpect(Again == Original, "accelerating_path: repeatable estimate");
for (K = 0; K < 110; K++)
{
HMPrice[K] *= 7.;
}
Scaled = HMForwardInference();
HMExpect(Scaled == Original, "accelerating_path: price-unit invariance");
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1. / HMPrice[K];
}
Reflected = HMForwardInference();
HMExpect(Reflected == -Original, "accelerating_path: directional reflection");
HMPrice[55] = 0.;
HMExpect(HMForwardInference() == 0, "accelerating_path: missing price rejected");
}
void HMCase_decelerating_path()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1.0 * exp(-0.0008 * K + 0.000002 * K * K + 0.0002 * cos(0.31 * K));
}
Original = HMForwardInference();
HMExpect(Original >= -1 && Original <= 1, "decelerating_path: bounded direction");
Again = HMForwardInference();
HMExpect(Again == Original, "decelerating_path: repeatable estimate");
for (K = 0; K < 110; K++)
{
HMPrice[K] *= 7.;
}
Scaled = HMForwardInference();
HMExpect(Scaled == Original, "decelerating_path: price-unit invariance");
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1. / HMPrice[K];
}
Reflected = HMForwardInference();
HMExpect(Reflected == -Original, "decelerating_path: directional reflection");
HMPrice[55] = 0.;
HMExpect(HMForwardInference() == 0, "decelerating_path: missing price rejected");
}
void HMCase_volatility_ramp()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1.0 * exp((0.0001 + K * 0.00001) * sin(0.37 * K));
}
Original = HMForwardInference();
HMExpect(Original >= -1 && Original <= 1, "volatility_ramp: bounded direction");
Again = HMForwardInference();
HMExpect(Again == Original, "volatility_ramp: repeatable estimate");
for (K = 0; K < 110; K++)
{
HMPrice[K] *= 7.;
}
Scaled = HMForwardInference();
HMExpect(Scaled == Original, "volatility_ramp: price-unit invariance");
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1. / HMPrice[K];
}
Reflected = HMForwardInference();
HMExpect(Reflected == -Original, "volatility_ramp: directional reflection");
HMPrice[55] = 0.;
HMExpect(HMForwardInference() == 0, "volatility_ramp: missing price rejected");
}
void HMCase_volatility_decay()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1.0 * exp(0.006 * exp(-0.02 * K) * cos(0.7 * K));
}
Original = HMForwardInference();
HMExpect(Original >= -1 && Original <= 1, "volatility_decay: bounded direction");
Again = HMForwardInference();
HMExpect(Again == Original, "volatility_decay: repeatable estimate");
for (K = 0; K < 110; K++)
{
HMPrice[K] *= 7.;
}
Scaled = HMForwardInference();
HMExpect(Scaled == Original, "volatility_decay: price-unit invariance");
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1. / HMPrice[K];
}
Reflected = HMForwardInference();
HMExpect(Reflected == -Original, "volatility_decay: directional reflection");
HMPrice[55] = 0.;
HMExpect(HMForwardInference() == 0, "volatility_decay: missing price rejected");
}
void HMCase_cycle_with_drift()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1.0 * exp(-0.0002 * K + 0.003 * sin(0.19 * K) + 0.0005 * cos(0.61 * K));
}
Original = HMForwardInference();
HMExpect(Original >= -1 && Original <= 1, "cycle_with_drift: bounded direction");
Again = HMForwardInference();
HMExpect(Again == Original, "cycle_with_drift: repeatable estimate");
for (K = 0; K < 110; K++)
{
HMPrice[K] *= 7.;
}
Scaled = HMForwardInference();
HMExpect(Scaled == Original, "cycle_with_drift: price-unit invariance");
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1. / HMPrice[K];
}
Reflected = HMForwardInference();
HMExpect(Reflected == -Original, "cycle_with_drift: directional reflection");
HMPrice[55] = 0.;
HMExpect(HMForwardInference() == 0, "cycle_with_drift: missing price rejected");
}
void HMCase_near_zero_prices()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 110; K++)
{
HMPrice[K] = 0.0001 * exp(0.002 * sin(0.29 * K) + 0.001 * cos(0.13 * K));
}
Original = HMForwardInference();
HMExpect(Original >= -1 && Original <= 1, "near_zero_prices: bounded direction");
Again = HMForwardInference();
HMExpect(Again == Original, "near_zero_prices: repeatable estimate");
for (K = 0; K < 110; K++)
{
HMPrice[K] *= 7.;
}
Scaled = HMForwardInference();
HMExpect(Scaled == Original, "near_zero_prices: price-unit invariance");
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1. / HMPrice[K];
}
Reflected = HMForwardInference();
HMExpect(Reflected == -Original, "near_zero_prices: directional reflection");
HMPrice[55] = 0.;
HMExpect(HMForwardInference() == 0, "near_zero_prices: missing price rejected");
}
void HMCase_large_price_units()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 110; K++)
{
HMPrice[K] = 10000.0 * exp(0.003 * sin(0.11 * K) + 0.0008 * cos(0.43 * K));
}
Original = HMForwardInference();
HMExpect(Original >= -1 && Original <= 1, "large_price_units: bounded direction");
Again = HMForwardInference();
HMExpect(Again == Original, "large_price_units: repeatable estimate");
for (K = 0; K < 110; K++)
{
HMPrice[K] *= 7.;
}
Scaled = HMForwardInference();
HMExpect(Scaled == Original, "large_price_units: price-unit invariance");
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1. / HMPrice[K];
}
Reflected = HMForwardInference();
HMExpect(Reflected == -Original, "large_price_units: directional reflection");
HMPrice[55] = 0.;
HMExpect(HMForwardInference() == 0, "large_price_units: missing price rejected");
}
void HMCase_high_frequency_chop()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1.0 * exp(0.0008 * cos(2.8 * K) + 0.001 * sin(0.23 * K));
}
Original = HMForwardInference();
HMExpect(Original >= -1 && Original <= 1, "high_frequency_chop: bounded direction");
Again = HMForwardInference();
HMExpect(Again == Original, "high_frequency_chop: repeatable estimate");
for (K = 0; K < 110; K++)
{
HMPrice[K] *= 7.;
}
Scaled = HMForwardInference();
HMExpect(Scaled == Original, "high_frequency_chop: price-unit invariance");
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1. / HMPrice[K];
}
Reflected = HMForwardInference();
HMExpect(Reflected == -Original, "high_frequency_chop: directional reflection");
HMPrice[55] = 0.;
HMExpect(HMForwardInference() == 0, "high_frequency_chop: missing price rejected");
}
void HMCase_long_wave_trend()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1.0 * exp(-0.0005 * K + 0.002 * cos(0.07 * K));
}
Original = HMForwardInference();
HMExpect(Original >= -1 && Original <= 1, "long_wave_trend: bounded direction");
Again = HMForwardInference();
HMExpect(Again == Original, "long_wave_trend: repeatable estimate");
for (K = 0; K < 110; K++)
{
HMPrice[K] *= 7.;
}
Scaled = HMForwardInference();
HMExpect(Scaled == Original, "long_wave_trend: price-unit invariance");
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1. / HMPrice[K];
}
Reflected = HMForwardInference();
HMExpect(Reflected == -Original, "long_wave_trend: directional reflection");
HMPrice[55] = 0.;
HMExpect(HMForwardInference() == 0, "long_wave_trend: missing price rejected");
}
void HMCase_opposing_scales()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1.0 * exp(0.005 * sin(0.09 * K) - 0.002 * sin(0.59 * K));
}
Original = HMForwardInference();
HMExpect(Original >= -1 && Original <= 1, "opposing_scales: bounded direction");
Again = HMForwardInference();
HMExpect(Again == Original, "opposing_scales: repeatable estimate");
for (K = 0; K < 110; K++)
{
HMPrice[K] *= 7.;
}
Scaled = HMForwardInference();
HMExpect(Scaled == Original, "opposing_scales: price-unit invariance");
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1. / HMPrice[K];
}
Reflected = HMForwardInference();
HMExpect(Reflected == -Original, "opposing_scales: directional reflection");
HMPrice[55] = 0.;
HMExpect(HMForwardInference() == 0, "opposing_scales: missing price rejected");
}
void HMCase_nonlinear_curve()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1.0 * exp(0.002 * sin(0.021 * K * K) + 0.001 * cos(0.33 * K));
}
Original = HMForwardInference();
HMExpect(Original >= -1 && Original <= 1, "nonlinear_curve: bounded direction");
Again = HMForwardInference();
HMExpect(Again == Original, "nonlinear_curve: repeatable estimate");
for (K = 0; K < 110; K++)
{
HMPrice[K] *= 7.;
}
Scaled = HMForwardInference();
HMExpect(Scaled == Original, "nonlinear_curve: price-unit invariance");
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1. / HMPrice[K];
}
Reflected = HMForwardInference();
HMExpect(Reflected == -Original, "nonlinear_curve: directional reflection");
HMPrice[55] = 0.;
HMExpect(HMForwardInference() == 0, "nonlinear_curve: missing price rejected");
}
void HMCase_amplitude_modulation()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1.0 * exp(0.002 * sin(0.3 * K) * cos(0.04 * K));
}
Original = HMForwardInference();
HMExpect(Original >= -1 && Original <= 1, "amplitude_modulation: bounded direction");
Again = HMForwardInference();
HMExpect(Again == Original, "amplitude_modulation: repeatable estimate");
for (K = 0; K < 110; K++)
{
HMPrice[K] *= 7.;
}
Scaled = HMForwardInference();
HMExpect(Scaled == Original, "amplitude_modulation: price-unit invariance");
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1. / HMPrice[K];
}
Reflected = HMForwardInference();
HMExpect(Reflected == -Original, "amplitude_modulation: directional reflection");
HMPrice[55] = 0.;
HMExpect(HMForwardInference() == 0, "amplitude_modulation: missing price rejected");
}
void HMCase_decaying_event()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1.0 * exp(0.01 * exp(-0.2 * K) + 0.0003 * sin(0.71 * K));
}
Original = HMForwardInference();
HMExpect(Original >= -1 && Original <= 1, "decaying_event: bounded direction");
Again = HMForwardInference();
HMExpect(Again == Original, "decaying_event: repeatable estimate");
for (K = 0; K < 110; K++)
{
HMPrice[K] *= 7.;
}
Scaled = HMForwardInference();
HMExpect(Scaled == Original, "decaying_event: price-unit invariance");
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1. / HMPrice[K];
}
Reflected = HMForwardInference();
HMExpect(Reflected == -Original, "decaying_event: directional reflection");
HMPrice[55] = 0.;
HMExpect(HMForwardInference() == 0, "decaying_event: missing price rejected");
}
void HMCase_time_varying_frequency()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1.0 * exp(0.002 * cos(0.004 * K * K + 0.11 * K));
}
Original = HMForwardInference();
HMExpect(Original >= -1 && Original <= 1, "time_varying_frequency: bounded direction");
Again = HMForwardInference();
HMExpect(Again == Original, "time_varying_frequency: repeatable estimate");
for (K = 0; K < 110; K++)
{
HMPrice[K] *= 7.;
}
Scaled = HMForwardInference();
HMExpect(Scaled == Original, "time_varying_frequency: price-unit invariance");
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1. / HMPrice[K];
}
Reflected = HMForwardInference();
HMExpect(Reflected == -Original, "time_varying_frequency: directional reflection");
HMPrice[55] = 0.;
HMExpect(HMForwardInference() == 0, "time_varying_frequency: missing price rejected");
}
void HMCase_slow_fast_cancellation()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1.0 * exp(0.004 * sin(0.07 * K) + 0.0013 * cos(0.97 * K));
}
Original = HMForwardInference();
HMExpect(Original >= -1 && Original <= 1, "slow_fast_cancellation: bounded direction");
Again = HMForwardInference();
HMExpect(Again == Original, "slow_fast_cancellation: repeatable estimate");
for (K = 0; K < 110; K++)
{
HMPrice[K] *= 7.;
}
Scaled = HMForwardInference();
HMExpect(Scaled == Original, "slow_fast_cancellation: price-unit invariance");
for (K = 0; K < 110; K++)
{
HMPrice[K] = 1. / HMPrice[K];
}
Reflected = HMForwardInference();
HMExpect(Reflected == -Original, "slow_fast_cancellation: directional reflection");
HMPrice[55] = 0.;
HMExpect(HMForwardInference() == 0, "slow_fast_cancellation: missing price rejected");
}
void HMExtendedTests()
{
HMExtendedCount = 0;
HMExtendedFailures = 0;
file_write("Log/TS08_HiddenMarkovCurve_extended.txt",
"TS08_HiddenMarkovCurve: extended properties\n", 0);
HMCase_quiet_cycle();
HMCase_mixed_cycles();
HMCase_persistent_upward();
HMCase_persistent_downward();
HMCase_slow_curve();
HMCase_rough_curve();
HMCase_accelerating_path();
HMCase_decelerating_path();
HMCase_volatility_ramp();
HMCase_volatility_decay();
HMCase_cycle_with_drift();
HMCase_near_zero_prices();
HMCase_large_price_units();
HMCase_high_frequency_chop();
HMCase_long_wave_trend();
HMCase_opposing_scales();
HMCase_nonlinear_curve();
HMCase_amplitude_modulation();
HMCase_decaying_event();
HMCase_time_varying_frequency();
HMCase_slow_fast_cancellation();
file_append("Log/TS08_HiddenMarkovCurve_extended.txt",
strf("RESULT: %d checks; %d failures\n", HMExtendedCount, HMExtendedFailures));
}
function run()
{
#ifdef STX_SELFTEST
if (is(INITRUN))
{
HMCheckPosterior();
HMExtendedTests();
quit("HMM tests complete");
}
return;
#endif
int T, Regime;
var Units, AtRisk;
BarPeriod = 60;
LookBack = 111;
Capital = 10000.;
StartDate = 20240101;
EndDate = 20241231;
MaxLong = 1;
MaxShort = 1;
Hedge = 0;
if (!asset("EUR/USD"))
{
return;
}
algo("HM08");
if (is(EXITRUN))
{
HMResearchDiagnostics();
return;
}
if (is(LOOKBACK))
{
return;
}
for (T = 0; T < 110; T++)
{
HMPrice[T] = priceClose(T + 1);
}
Regime = HMForwardInference();
if (NumOpenLong > 0 && HMProbability[0] < 0.45)
{
exitLong();
}
if (NumOpenShort > 0 && HMProbability[1] < 0.45)
{
exitShort();
}
if (Regime == 0 || NumOpenLong + NumOpenShort > 0)
{
return;
}
if (Balance <= 0. || Equity <= Balance * 0.85)
{
return;
}
if (MarginCost <= 0. || PIP <= 0. || PIPCost <= 0. || LotAmount <= 0.)
{
return;
}
Stop = 50. * PIP;
TakeProfit = 125. * PIP;
LifeTime = 32;
AtRisk = PIPCost * (Stop + Spread) / PIP + Commission * LotAmount / 10000.;
if (AtRisk <= 0.)
{
return;
}
Units = min(2000. / LotAmount, Balance * 0.005 / AtRisk);
Units = min(Units, max(0., Equity - MarginVal) * 0.8 / MarginCost);
if (Units < 1.)
{
return;
}
Lots = floor(Units);
Margin = 0.;
Risk = 0.;
if (Regime > 0)
{
enterLong();
}
else
{
enterShort();
}
}
|
|
|
Entropy Analogues
[Re: TipmyPip]
#489732
Yesterday at 09:06
Yesterday at 09:06
|
Joined: Sep 2017
Posts: 355
TipmyPip
OP
Senior Member
|
OP
Senior Member
Joined: Sep 2017
Posts: 355
|
Entropy Analogues — The Historical Pattern Library Imagine a library whose books describe earlier shapes of the market's return curve. Instead of imposing one fixed trend equation, the program asks whether the current arrangement resembles patterns already present in that library. It then looks at what followed those earlier patterns, using only outcomes that are already known at the current decision time. Before searching the shelves, the program measures an aspect of local disorder. It records the relative ordering of neighboring returns and counts how frequently different orderings appear. When those orderings are distributed almost uniformly, the market receives a high entropy reading. That suggests weak ordinal structure and reduces the justification for interpreting nearby patterns as useful analogues. The pattern description itself contains average returns across several horizons. Historical scale estimates keep one horizon from dominating the distance calculation merely because its typical numerical movement is larger. The program compares the current curve with eligible older curves and retains a small collection of the nearest matches. The historical candidates are separated from the newest observation by a safety gap. Their subsequent short horizon outcomes have already occurred, so the program does not borrow information from the actual future of the current decision. Each selected candidate contributes its known outcome, with closer matches receiving greater weight in the forecast. An entry requires more than a positive or negative weighted average. The selected matches must be reasonably close, the entropy gate must permit interpretation, and the forecast must be meaningful relative to disagreement among the historical outcomes. A positive accepted forecast supports buying, while a negative accepted forecast supports selling. The intended prediction horizon is short, and the position lifetime reflects that horizon. Strong disorder can close existing positions, while an accepted forecast in the opposite direction can cause the strategy to exit before considering reversal. Protective price exits and exposure limits remain necessary because even a well matched analogue can lead to a different subsequent path. Additional diagnostics describe recurrence frequency, dispersion of historical forward outcomes, and the complement of ordinal entropy. These provide context for how frequently similar patterns appear and how consistent their consequences have been. The library metaphor exposes several weaknesses. Neighboring historical candidates can overlap and therefore fail to represent independent examples. The same apparent shape can arise under different economic conditions. Distance thresholds and the number of selected neighbors are research choices rather than universal constants. The program is a local historical forecasting experiment, not proof that markets repeat themselves or that remembered patterns remain profitable after trading costs. // Independent model 09: ordinal entropy, return-curve recurrence and analogues.
#include <default.c>
var NNPrices[180];
var NNForecast = 0.;
var NNEntropy = 1.;
int NNUsed = 0;
int NNHorizons[3] = {1, 4, 16};
int NNOrdinal(var A, var B, var C)
{
if (A <= B && B <= C)
{
return 0;
}
if (A <= C && C < B)
{
return 1;
}
if (B < A && A <= C)
{
return 2;
}
if (B <= C && C < A)
{
return 3;
}
if (C < A && A <= B)
{
return 4;
}
return 5;
}
int NNFindRecurrences()
{
int T, J, Rank, Slot, Pattern;
int Frequency[6];
var CurrentCurve[3];
var Scale[3];
var Mean[3];
var Nearest[8];
var Outcomes[8];
var A, B, C, Feature, Difference, Distance, Target, Probability, Weight, SumWeight, Variance;
NNForecast = 0.;
NNUsed = 0.;
NNEntropy = 0.;
for (T = 0; T < 180; T++)
{
if (!(NNPrices[T] > 0.))
{
return 0;
}
}
for (Pattern = 0; Pattern < 6; Pattern++)
{
Frequency[Pattern] = 0;
}
for (T = 1; T <= 48; T++)
{
A = log(NNPrices[T] / NNPrices[T + 1]);
B = log(NNPrices[T + 1] / NNPrices[T + 2]);
C = log(NNPrices[T + 2] / NNPrices[T + 3]);
Frequency[NNOrdinal(A, B, C)]++;
}
for (Pattern = 0; Pattern < 6; Pattern++)
{
Probability = Frequency[Pattern] / 48.;
if (Probability > 0.)
{
NNEntropy -= Probability * log(Probability) / log(6.);
}
}
for (J = 0; J < 3; J++)
{
Mean[J] = 0.;
Scale[J] = 0.;
for (T = 12; T <= 140; T++)
{
Mean[J] += log(NNPrices[T] / NNPrices[T + NNHorizons[J]]) / NNHorizons[J] / 129.;
}
for (T = 12; T <= 140; T++)
{
Feature = log(NNPrices[T] / NNPrices[T + NNHorizons[J]]) / NNHorizons[J];
Scale[J] += (Feature - Mean[J]) * (Feature - Mean[J]) / 129.;
}
if (Scale[J] < 1.e-22)
{
return 0;
}
CurrentCurve[J] = log(NNPrices[0] / NNPrices[NNHorizons[J]]) / NNHorizons[J];
}
for (Rank = 0; Rank < 8; Rank++)
{
Nearest[Rank] = 1.e100;
Outcomes[Rank] = 0.;
}
for (T = 12; T <= 140; T++)
{
Distance = 0.;
for (J = 0; J < 3; J++)
{
Feature = log(NNPrices[T] / NNPrices[T + NNHorizons[J]]) / NNHorizons[J];
Difference = CurrentCurve[J] - Feature;
Distance += Difference * Difference / Scale[J];
}
// The forward target of every historical analogue is already observable.
Target = log(NNPrices[T - 4] / NNPrices[T]);
for (Rank = 0; Rank < 8; Rank++)
{
if (Distance < Nearest[Rank])
{
for (Slot = 7; Slot > Rank; Slot--)
{
Nearest[Slot] = Nearest[Slot - 1];
Outcomes[Slot] = Outcomes[Slot - 1];
}
Nearest[Rank] = Distance;
Outcomes[Rank] = Target;
break;
}
}
}
SumWeight = 0.;
Variance = 0.;
for (Rank = 0; Rank < 8; Rank++)
{
Weight = 1. / (0.1 + Nearest[Rank]);
NNForecast += Weight * Outcomes[Rank];
SumWeight += Weight;
NNUsed++;
}
if (SumWeight <= 0.)
{
return 0;
}
NNForecast /= SumWeight;
for (Rank = 0; Rank < 8; Rank++)
{
Difference = Outcomes[Rank] - NNForecast;
Variance += Difference * Difference / 8.;
}
if (NNEntropy > 0.97 || Nearest[7] > 4.)
{
return 0;
}
if (abs(NNForecast) < sqrt(max(1.e-22, Variance)) * 0.5)
{
return 0;
}
if (NNForecast > 0.)
{
return 1;
}
if (NNForecast < 0.)
{
return -1;
}
return 0;
}
void NNTestHistory()
{
int T, One, Mirror, Mistakes;
Mistakes = 0;
for (T = 0; T < 180; T++)
{
NNPrices[T] = 1.;
}
if (NNFindRecurrences() != 0)
{
Mistakes++;
}
for (T = 0; T < 180; T++)
{
NNPrices[T] = exp(0.003 * sin(0.17 * T) + 0.001 * cos(0.41 * T));
}
One = NNFindRecurrences();
if (NNUsed != 8 || One < -1 || One > 1)
{
Mistakes++;
}
for (T = 0; T < 180; T++)
{
NNPrices[T] = 1. / NNPrices[T];
}
Mirror = NNFindRecurrences();
if (Mirror != -One)
{
Mistakes++;
}
NNPrices[0] = -1.;
if (NNFindRecurrences() != 0)
{
Mistakes++;
}
file_write("Log/TS09_EntropyAnalogues_test.txt", strf("4 checks; %d failures\n", Mistakes), 0);
}
var NNRecurrenceRate(var MaximumDistance)
{
int T, J, Hits;
var Distance, Difference, Current, Historic;
if (MaximumDistance <= 0.)
{
return 0.;
}
Hits = 0;
for (T = 16; T <= 140; T++)
{
Distance = 0.;
for (J = 0; J < 3; J++)
{
Current = log(NNPrices[0] / NNPrices[NNHorizons[J]]) / NNHorizons[J];
Historic = log(NNPrices[T] / NNPrices[T + NNHorizons[J]]) / NNHorizons[J];
Difference = Current - Historic;
Distance += Difference * Difference;
}
if (sqrt(Distance) < MaximumDistance)
{
Hits++;
}
}
return Hits / 125.;
}
var NNForwardTargetDispersion()
{
int T;
var Y, MeanTarget, VarTarget;
MeanTarget = 0.;
VarTarget = 0.;
for (T = 12; T <= 140; T++)
{
MeanTarget += log(NNPrices[T - 4] / NNPrices[T]) / 129.;
}
for (T = 12; T <= 140; T++)
{
Y = log(NNPrices[T - 4] / NNPrices[T]) - MeanTarget;
VarTarget += Y * Y / 129.;
}
return sqrt(VarTarget);
}
var NNInformationComplement()
{
return max(0., 1. - NNEntropy);
}
void NNResearchDiagnostics()
{
printf(
"\nAnalogues %d; recurrence rate %.6g; target dispersion %.6g; information complement %.6g",
NNUsed, NNRecurrenceRate(0.001), NNForwardTargetDispersion(), NNInformationComplement());
}
// ============================================================================
// EXTENDED REGRESSION SUITE: deterministic properties over market regimes
// These functions run ONLY under STX_SELFTEST; they never place orders.
// ============================================================================
int NNExtendedCount = 0;
int NNExtendedFailures = 0;
void NNExpect(int Passed, string Description)
{
NNExtendedCount++;
if (!Passed)
{
NNExtendedFailures++;
file_append("Log/TS09_EntropyAnalogues_extended.txt", strf("FAIL: %s\n", Description));
}
}
void NNCase_quiet_cycle()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1.0 * exp(0.0005 * sin(0.17 * K));
}
Original = NNFindRecurrences();
NNExpect(Original >= -1 && Original <= 1, "quiet_cycle: bounded direction");
Again = NNFindRecurrences();
NNExpect(Again == Original, "quiet_cycle: repeatable estimate");
for (K = 0; K < 180; K++)
{
NNPrices[K] *= 7.;
}
Scaled = NNFindRecurrences();
NNExpect(Scaled == Original, "quiet_cycle: price-unit invariance");
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1. / NNPrices[K];
}
Reflected = NNFindRecurrences();
NNExpect(Reflected == -Original, "quiet_cycle: directional reflection");
NNPrices[90] = 0.;
NNExpect(NNFindRecurrences() == 0, "quiet_cycle: missing price rejected");
}
void NNCase_mixed_cycles()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1.0 * exp(0.003 * sin(0.23 * K) + 0.0007 * cos(0.81 * K));
}
Original = NNFindRecurrences();
NNExpect(Original >= -1 && Original <= 1, "mixed_cycles: bounded direction");
Again = NNFindRecurrences();
NNExpect(Again == Original, "mixed_cycles: repeatable estimate");
for (K = 0; K < 180; K++)
{
NNPrices[K] *= 7.;
}
Scaled = NNFindRecurrences();
NNExpect(Scaled == Original, "mixed_cycles: price-unit invariance");
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1. / NNPrices[K];
}
Reflected = NNFindRecurrences();
NNExpect(Reflected == -Original, "mixed_cycles: directional reflection");
NNPrices[90] = 0.;
NNExpect(NNFindRecurrences() == 0, "mixed_cycles: missing price rejected");
}
void NNCase_persistent_upward()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1.0 * exp(-0.001 * K + 0.0001 * sin(0.53 * K));
}
Original = NNFindRecurrences();
NNExpect(Original >= -1 && Original <= 1, "persistent_upward: bounded direction");
Again = NNFindRecurrences();
NNExpect(Again == Original, "persistent_upward: repeatable estimate");
for (K = 0; K < 180; K++)
{
NNPrices[K] *= 7.;
}
Scaled = NNFindRecurrences();
NNExpect(Scaled == Original, "persistent_upward: price-unit invariance");
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1. / NNPrices[K];
}
Reflected = NNFindRecurrences();
NNExpect(Reflected == -Original, "persistent_upward: directional reflection");
NNPrices[90] = 0.;
NNExpect(NNFindRecurrences() == 0, "persistent_upward: missing price rejected");
}
void NNCase_persistent_downward()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1.0 * exp(0.001 * K + 0.0001 * cos(0.47 * K));
}
Original = NNFindRecurrences();
NNExpect(Original >= -1 && Original <= 1, "persistent_downward: bounded direction");
Again = NNFindRecurrences();
NNExpect(Again == Original, "persistent_downward: repeatable estimate");
for (K = 0; K < 180; K++)
{
NNPrices[K] *= 7.;
}
Scaled = NNFindRecurrences();
NNExpect(Scaled == Original, "persistent_downward: price-unit invariance");
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1. / NNPrices[K];
}
Reflected = NNFindRecurrences();
NNExpect(Reflected == -Original, "persistent_downward: directional reflection");
NNPrices[90] = 0.;
NNExpect(NNFindRecurrences() == 0, "persistent_downward: missing price rejected");
}
void NNCase_slow_curve()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1.0 * exp(0.004 * cos(0.08 * K) + 0.0002 * sin(0.7 * K));
}
Original = NNFindRecurrences();
NNExpect(Original >= -1 && Original <= 1, "slow_curve: bounded direction");
Again = NNFindRecurrences();
NNExpect(Again == Original, "slow_curve: repeatable estimate");
for (K = 0; K < 180; K++)
{
NNPrices[K] *= 7.;
}
Scaled = NNFindRecurrences();
NNExpect(Scaled == Original, "slow_curve: price-unit invariance");
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1. / NNPrices[K];
}
Reflected = NNFindRecurrences();
NNExpect(Reflected == -Original, "slow_curve: directional reflection");
NNPrices[90] = 0.;
NNExpect(NNFindRecurrences() == 0, "slow_curve: missing price rejected");
}
void NNCase_rough_curve()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1.0 * exp(0.001 * sin(1.7 * K) + 0.0005 * cos(2.3 * K));
}
Original = NNFindRecurrences();
NNExpect(Original >= -1 && Original <= 1, "rough_curve: bounded direction");
Again = NNFindRecurrences();
NNExpect(Again == Original, "rough_curve: repeatable estimate");
for (K = 0; K < 180; K++)
{
NNPrices[K] *= 7.;
}
Scaled = NNFindRecurrences();
NNExpect(Scaled == Original, "rough_curve: price-unit invariance");
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1. / NNPrices[K];
}
Reflected = NNFindRecurrences();
NNExpect(Reflected == -Original, "rough_curve: directional reflection");
NNPrices[90] = 0.;
NNExpect(NNFindRecurrences() == 0, "rough_curve: missing price rejected");
}
void NNCase_accelerating_path()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1.0 * exp(-0.0001 * K - 0.000002 * K * K + 0.0002 * sin(0.41 * K));
}
Original = NNFindRecurrences();
NNExpect(Original >= -1 && Original <= 1, "accelerating_path: bounded direction");
Again = NNFindRecurrences();
NNExpect(Again == Original, "accelerating_path: repeatable estimate");
for (K = 0; K < 180; K++)
{
NNPrices[K] *= 7.;
}
Scaled = NNFindRecurrences();
NNExpect(Scaled == Original, "accelerating_path: price-unit invariance");
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1. / NNPrices[K];
}
Reflected = NNFindRecurrences();
NNExpect(Reflected == -Original, "accelerating_path: directional reflection");
NNPrices[90] = 0.;
NNExpect(NNFindRecurrences() == 0, "accelerating_path: missing price rejected");
}
void NNCase_decelerating_path()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1.0 * exp(-0.0008 * K + 0.000002 * K * K + 0.0002 * cos(0.31 * K));
}
Original = NNFindRecurrences();
NNExpect(Original >= -1 && Original <= 1, "decelerating_path: bounded direction");
Again = NNFindRecurrences();
NNExpect(Again == Original, "decelerating_path: repeatable estimate");
for (K = 0; K < 180; K++)
{
NNPrices[K] *= 7.;
}
Scaled = NNFindRecurrences();
NNExpect(Scaled == Original, "decelerating_path: price-unit invariance");
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1. / NNPrices[K];
}
Reflected = NNFindRecurrences();
NNExpect(Reflected == -Original, "decelerating_path: directional reflection");
NNPrices[90] = 0.;
NNExpect(NNFindRecurrences() == 0, "decelerating_path: missing price rejected");
}
void NNCase_volatility_ramp()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1.0 * exp((0.0001 + K * 0.00001) * sin(0.37 * K));
}
Original = NNFindRecurrences();
NNExpect(Original >= -1 && Original <= 1, "volatility_ramp: bounded direction");
Again = NNFindRecurrences();
NNExpect(Again == Original, "volatility_ramp: repeatable estimate");
for (K = 0; K < 180; K++)
{
NNPrices[K] *= 7.;
}
Scaled = NNFindRecurrences();
NNExpect(Scaled == Original, "volatility_ramp: price-unit invariance");
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1. / NNPrices[K];
}
Reflected = NNFindRecurrences();
NNExpect(Reflected == -Original, "volatility_ramp: directional reflection");
NNPrices[90] = 0.;
NNExpect(NNFindRecurrences() == 0, "volatility_ramp: missing price rejected");
}
void NNCase_volatility_decay()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1.0 * exp(0.006 * exp(-0.02 * K) * cos(0.7 * K));
}
Original = NNFindRecurrences();
NNExpect(Original >= -1 && Original <= 1, "volatility_decay: bounded direction");
Again = NNFindRecurrences();
NNExpect(Again == Original, "volatility_decay: repeatable estimate");
for (K = 0; K < 180; K++)
{
NNPrices[K] *= 7.;
}
Scaled = NNFindRecurrences();
NNExpect(Scaled == Original, "volatility_decay: price-unit invariance");
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1. / NNPrices[K];
}
Reflected = NNFindRecurrences();
NNExpect(Reflected == -Original, "volatility_decay: directional reflection");
NNPrices[90] = 0.;
NNExpect(NNFindRecurrences() == 0, "volatility_decay: missing price rejected");
}
void NNCase_cycle_with_drift()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1.0 * exp(-0.0002 * K + 0.003 * sin(0.19 * K) + 0.0005 * cos(0.61 * K));
}
Original = NNFindRecurrences();
NNExpect(Original >= -1 && Original <= 1, "cycle_with_drift: bounded direction");
Again = NNFindRecurrences();
NNExpect(Again == Original, "cycle_with_drift: repeatable estimate");
for (K = 0; K < 180; K++)
{
NNPrices[K] *= 7.;
}
Scaled = NNFindRecurrences();
NNExpect(Scaled == Original, "cycle_with_drift: price-unit invariance");
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1. / NNPrices[K];
}
Reflected = NNFindRecurrences();
NNExpect(Reflected == -Original, "cycle_with_drift: directional reflection");
NNPrices[90] = 0.;
NNExpect(NNFindRecurrences() == 0, "cycle_with_drift: missing price rejected");
}
void NNCase_near_zero_prices()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 180; K++)
{
NNPrices[K] = 0.0001 * exp(0.002 * sin(0.29 * K) + 0.001 * cos(0.13 * K));
}
Original = NNFindRecurrences();
NNExpect(Original >= -1 && Original <= 1, "near_zero_prices: bounded direction");
Again = NNFindRecurrences();
NNExpect(Again == Original, "near_zero_prices: repeatable estimate");
for (K = 0; K < 180; K++)
{
NNPrices[K] *= 7.;
}
Scaled = NNFindRecurrences();
NNExpect(Scaled == Original, "near_zero_prices: price-unit invariance");
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1. / NNPrices[K];
}
Reflected = NNFindRecurrences();
NNExpect(Reflected == -Original, "near_zero_prices: directional reflection");
NNPrices[90] = 0.;
NNExpect(NNFindRecurrences() == 0, "near_zero_prices: missing price rejected");
}
void NNCase_large_price_units()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 180; K++)
{
NNPrices[K] = 10000.0 * exp(0.003 * sin(0.11 * K) + 0.0008 * cos(0.43 * K));
}
Original = NNFindRecurrences();
NNExpect(Original >= -1 && Original <= 1, "large_price_units: bounded direction");
Again = NNFindRecurrences();
NNExpect(Again == Original, "large_price_units: repeatable estimate");
for (K = 0; K < 180; K++)
{
NNPrices[K] *= 7.;
}
Scaled = NNFindRecurrences();
NNExpect(Scaled == Original, "large_price_units: price-unit invariance");
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1. / NNPrices[K];
}
Reflected = NNFindRecurrences();
NNExpect(Reflected == -Original, "large_price_units: directional reflection");
NNPrices[90] = 0.;
NNExpect(NNFindRecurrences() == 0, "large_price_units: missing price rejected");
}
void NNCase_high_frequency_chop()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1.0 * exp(0.0008 * cos(2.8 * K) + 0.001 * sin(0.23 * K));
}
Original = NNFindRecurrences();
NNExpect(Original >= -1 && Original <= 1, "high_frequency_chop: bounded direction");
Again = NNFindRecurrences();
NNExpect(Again == Original, "high_frequency_chop: repeatable estimate");
for (K = 0; K < 180; K++)
{
NNPrices[K] *= 7.;
}
Scaled = NNFindRecurrences();
NNExpect(Scaled == Original, "high_frequency_chop: price-unit invariance");
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1. / NNPrices[K];
}
Reflected = NNFindRecurrences();
NNExpect(Reflected == -Original, "high_frequency_chop: directional reflection");
NNPrices[90] = 0.;
NNExpect(NNFindRecurrences() == 0, "high_frequency_chop: missing price rejected");
}
void NNCase_long_wave_trend()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1.0 * exp(-0.0005 * K + 0.002 * cos(0.07 * K));
}
Original = NNFindRecurrences();
NNExpect(Original >= -1 && Original <= 1, "long_wave_trend: bounded direction");
Again = NNFindRecurrences();
NNExpect(Again == Original, "long_wave_trend: repeatable estimate");
for (K = 0; K < 180; K++)
{
NNPrices[K] *= 7.;
}
Scaled = NNFindRecurrences();
NNExpect(Scaled == Original, "long_wave_trend: price-unit invariance");
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1. / NNPrices[K];
}
Reflected = NNFindRecurrences();
NNExpect(Reflected == -Original, "long_wave_trend: directional reflection");
NNPrices[90] = 0.;
NNExpect(NNFindRecurrences() == 0, "long_wave_trend: missing price rejected");
}
void NNCase_opposing_scales()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1.0 * exp(0.005 * sin(0.09 * K) - 0.002 * sin(0.59 * K));
}
Original = NNFindRecurrences();
NNExpect(Original >= -1 && Original <= 1, "opposing_scales: bounded direction");
Again = NNFindRecurrences();
NNExpect(Again == Original, "opposing_scales: repeatable estimate");
for (K = 0; K < 180; K++)
{
NNPrices[K] *= 7.;
}
Scaled = NNFindRecurrences();
NNExpect(Scaled == Original, "opposing_scales: price-unit invariance");
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1. / NNPrices[K];
}
Reflected = NNFindRecurrences();
NNExpect(Reflected == -Original, "opposing_scales: directional reflection");
NNPrices[90] = 0.;
NNExpect(NNFindRecurrences() == 0, "opposing_scales: missing price rejected");
}
void NNCase_nonlinear_curve()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1.0 * exp(0.002 * sin(0.021 * K * K) + 0.001 * cos(0.33 * K));
}
Original = NNFindRecurrences();
NNExpect(Original >= -1 && Original <= 1, "nonlinear_curve: bounded direction");
Again = NNFindRecurrences();
NNExpect(Again == Original, "nonlinear_curve: repeatable estimate");
for (K = 0; K < 180; K++)
{
NNPrices[K] *= 7.;
}
Scaled = NNFindRecurrences();
NNExpect(Scaled == Original, "nonlinear_curve: price-unit invariance");
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1. / NNPrices[K];
}
Reflected = NNFindRecurrences();
NNExpect(Reflected == -Original, "nonlinear_curve: directional reflection");
NNPrices[90] = 0.;
NNExpect(NNFindRecurrences() == 0, "nonlinear_curve: missing price rejected");
}
void NNCase_amplitude_modulation()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1.0 * exp(0.002 * sin(0.3 * K) * cos(0.04 * K));
}
Original = NNFindRecurrences();
NNExpect(Original >= -1 && Original <= 1, "amplitude_modulation: bounded direction");
Again = NNFindRecurrences();
NNExpect(Again == Original, "amplitude_modulation: repeatable estimate");
for (K = 0; K < 180; K++)
{
NNPrices[K] *= 7.;
}
Scaled = NNFindRecurrences();
NNExpect(Scaled == Original, "amplitude_modulation: price-unit invariance");
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1. / NNPrices[K];
}
Reflected = NNFindRecurrences();
NNExpect(Reflected == -Original, "amplitude_modulation: directional reflection");
NNPrices[90] = 0.;
NNExpect(NNFindRecurrences() == 0, "amplitude_modulation: missing price rejected");
}
void NNCase_decaying_event()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1.0 * exp(0.01 * exp(-0.2 * K) + 0.0003 * sin(0.71 * K));
}
Original = NNFindRecurrences();
NNExpect(Original >= -1 && Original <= 1, "decaying_event: bounded direction");
Again = NNFindRecurrences();
NNExpect(Again == Original, "decaying_event: repeatable estimate");
for (K = 0; K < 180; K++)
{
NNPrices[K] *= 7.;
}
Scaled = NNFindRecurrences();
NNExpect(Scaled == Original, "decaying_event: price-unit invariance");
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1. / NNPrices[K];
}
Reflected = NNFindRecurrences();
NNExpect(Reflected == -Original, "decaying_event: directional reflection");
NNPrices[90] = 0.;
NNExpect(NNFindRecurrences() == 0, "decaying_event: missing price rejected");
}
void NNCase_time_varying_frequency()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1.0 * exp(0.002 * cos(0.004 * K * K + 0.11 * K));
}
Original = NNFindRecurrences();
NNExpect(Original >= -1 && Original <= 1, "time_varying_frequency: bounded direction");
Again = NNFindRecurrences();
NNExpect(Again == Original, "time_varying_frequency: repeatable estimate");
for (K = 0; K < 180; K++)
{
NNPrices[K] *= 7.;
}
Scaled = NNFindRecurrences();
NNExpect(Scaled == Original, "time_varying_frequency: price-unit invariance");
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1. / NNPrices[K];
}
Reflected = NNFindRecurrences();
NNExpect(Reflected == -Original, "time_varying_frequency: directional reflection");
NNPrices[90] = 0.;
NNExpect(NNFindRecurrences() == 0, "time_varying_frequency: missing price rejected");
}
void NNCase_slow_fast_cancellation()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1.0 * exp(0.004 * sin(0.07 * K) + 0.0013 * cos(0.97 * K));
}
Original = NNFindRecurrences();
NNExpect(Original >= -1 && Original <= 1, "slow_fast_cancellation: bounded direction");
Again = NNFindRecurrences();
NNExpect(Again == Original, "slow_fast_cancellation: repeatable estimate");
for (K = 0; K < 180; K++)
{
NNPrices[K] *= 7.;
}
Scaled = NNFindRecurrences();
NNExpect(Scaled == Original, "slow_fast_cancellation: price-unit invariance");
for (K = 0; K < 180; K++)
{
NNPrices[K] = 1. / NNPrices[K];
}
Reflected = NNFindRecurrences();
NNExpect(Reflected == -Original, "slow_fast_cancellation: directional reflection");
NNPrices[90] = 0.;
NNExpect(NNFindRecurrences() == 0, "slow_fast_cancellation: missing price rejected");
}
void NNExtendedTests()
{
NNExtendedCount = 0;
NNExtendedFailures = 0;
file_write("Log/TS09_EntropyAnalogues_extended.txt",
"TS09_EntropyAnalogues: extended properties\n", 0);
NNCase_quiet_cycle();
NNCase_mixed_cycles();
NNCase_persistent_upward();
NNCase_persistent_downward();
NNCase_slow_curve();
NNCase_rough_curve();
NNCase_accelerating_path();
NNCase_decelerating_path();
NNCase_volatility_ramp();
NNCase_volatility_decay();
NNCase_cycle_with_drift();
NNCase_near_zero_prices();
NNCase_large_price_units();
NNCase_high_frequency_chop();
NNCase_long_wave_trend();
NNCase_opposing_scales();
NNCase_nonlinear_curve();
NNCase_amplitude_modulation();
NNCase_decaying_event();
NNCase_time_varying_frequency();
NNCase_slow_fast_cancellation();
file_append("Log/TS09_EntropyAnalogues_extended.txt",
strf("RESULT: %d checks; %d failures\n", NNExtendedCount, NNExtendedFailures));
}
function run()
{
#ifdef STX_SELFTEST
if (is(INITRUN))
{
NNTestHistory();
NNExtendedTests();
quit("Analogue tests complete");
}
return;
#endif
int T, AnalogueSide;
var Limit, UnitRisk;
BarPeriod = 60;
LookBack = 181;
StartDate = 20240101;
EndDate = 20241231;
Capital = 10000.;
Hedge = 0;
MaxLong = 1;
MaxShort = 1;
if (!asset("EUR/USD"))
{
return;
}
algo("NN09");
if (is(EXITRUN))
{
NNResearchDiagnostics();
return;
}
if (is(LOOKBACK))
{
return;
}
for (T = 0; T < 180; T++)
{
NNPrices[T] = priceClose(T + 1);
}
AnalogueSide = NNFindRecurrences();
if (NNEntropy > 0.98)
{
exitLong();
exitShort();
return;
}
if (AnalogueSide > 0)
{
exitShort();
}
if (AnalogueSide < 0)
{
exitLong();
}
if (AnalogueSide == 0 || NumOpenLong + NumOpenShort > 0)
{
return;
}
if (Balance <= 0. || Equity < Balance * 0.85)
{
return;
}
if (LotAmount <= 0. || MarginCost <= 0. || PIP <= 0. || PIPCost <= 0.)
{
return;
}
Stop = 35. * PIP;
TakeProfit = 70. * PIP;
LifeTime = 4;
UnitRisk = (Stop + Spread) / PIP * PIPCost + Commission * LotAmount / 10000.;
if (UnitRisk <= 0.)
{
return;
}
Limit = min(Balance * 0.005 / UnitRisk, 2000. / LotAmount);
Limit = min(Limit, max(0., Equity - MarginVal) * 0.8 / MarginCost);
if (Limit < 1.)
{
return;
}
Lots = floor(Limit);
Margin = 0.;
Risk = 0.;
if (AnalogueSide > 0)
{
enterLong();
}
else
{
enterShort();
}
}
|
|
|
Robust Quantile Curve
[Re: TipmyPip]
#489733
Yesterday at 09:08
Yesterday at 09:08
|
Joined: Sep 2017
Posts: 355
TipmyPip
OP
Senior Member
|
OP
Senior Member
Joined: Sep 2017
Posts: 355
|
Robust Quantile Curve — The Flexible Ruler Imagine measuring a flexible ruler that bends differently at short and long observation horizons. The ruler represents average price returns across several horizons. Instead of allowing one unusual point to determine its shape, the program uses a robust construction designed to describe the broad relationship among those observations. For each observation time, the program compares pairs of horizon readings and obtains a collection of possible slopes along the horizon axis. It then takes the median of those slopes. This Theil–Sen construction is less dependent on a single extreme reading than an ordinary line fitted only by minimizing squared errors. The program repeats that construction across a historical window, creating a time series of robust curve slopes. It sorts the historical slopes to obtain their median and empirical quantiles. It also measures typical displacement from the historical center using the median absolute deviation. These references describe the usual shape of the ruler without assuming that the entire distribution follows a perfect bell curve. The newest curve is examined in two complementary ways. Its empirical rank indicates whether it lies near an edge of the historical distribution. Its robust displacement score indicates whether it is meaningfully far from the historical center. Both must support an extreme interpretation before the program considers a trade. There is also a turning requirement. The curve must begin moving back toward the historical center while still remaining unusually displaced. A high long horizon versus short horizon slope suggests that near horizon returns have lagged; when this distortion starts easing, the strategy considers buying. The corresponding low extreme turning upward supports selling. This is a curve normalization hypothesis rather than a simple momentum rule. Existing positions can be closed when the robust displacement becomes small or when the curve rank returns toward the middle of its historical range. The strategy does not need to wait for an opposite extreme to recognize that the original distortion has largely disappeared. Price based protection, constrained exposure, and a maximum holding period provide separate safeguards. Research diagnostics describe quantile asymmetry, the width between outer historical quantiles, and the typical change between successive robust curve slopes. These help distinguish a stable distribution with a temporary distortion from a curve whose entire historical distribution is shifting. Robustness does not establish economic causality. Horizon returns overlap, historical quantiles can change, and a turn toward an old center can be temporary. The analytical curve is not a separately traded instrument. Converting its normalization into a directional Forex trade remains an experimental interpretation requiring cost aware, out of sample validation. // Independent model 10: Theil-Sen curve geometry, median/QValueMAD and quantile ranks.
#include <default.c>
var QPrice[120];
var QCurveHistory[65];
var QSorted[64];
var QDeviation[64];
var QRobustScore = 0.;
var QPercentile = 0.5;
int QTenors[6] = {1, 2, 4, 8, 16, 32};
void QInsertionSort(vars Values, int Length)
{
int At, Back;
var Saved;
for (At = 1; At < Length; At++)
{
Saved = Values[At];
Back = At - 1;
while (Back >= 0)
{
if (Values[Back] <= Saved)
{
break;
}
Values[Back + 1] = Values[Back];
Back--;
}
Values[Back + 1] = Saved;
}
}
var QTheilSenAt(int QValueOffset)
{
var Rates[6];
var PairSlope[15];
int Short, Long, Pair;
for (Short = 0; Short < 6; Short++)
{
Rates[Short] =
log(QPrice[QValueOffset] / QPrice[QValueOffset + QTenors[Short]]) / QTenors[Short];
}
Pair = 0;
for (Short = 0; Short < 5; Short++)
{
for (Long = Short + 1; Long < 6; Long++)
{
PairSlope[Pair] =
(Rates[Long] - Rates[Short]) / (log(QTenors[Long]) - log(QTenors[Short]));
Pair++;
}
}
QInsertionSort(PairSlope, 15);
return PairSlope[7];
}
int QEstimateShape()
{
int QValueOffset, QValueLess, QValueEqual;
var QValueCenter, QValueMAD, QValueInterquartile, QValueNow;
QRobustScore = 0.;
QPercentile = 0.5;
for (QValueOffset = 0; QValueOffset < 120; QValueOffset++)
{
if (!(QPrice[QValueOffset] > 0.))
{
return 0;
}
}
for (QValueOffset = 0; QValueOffset <= 64; QValueOffset++)
{
QCurveHistory[QValueOffset] = QTheilSenAt(QValueOffset);
}
for (QValueOffset = 0; QValueOffset < 64; QValueOffset++)
{
QSorted[QValueOffset] = QCurveHistory[QValueOffset + 1];
}
QInsertionSort(QSorted, 64);
QValueCenter = (QSorted[31] + QSorted[32]) / 2.;
QValueInterquartile = QSorted[48] - QSorted[16];
for (QValueOffset = 0; QValueOffset < 64; QValueOffset++)
{
QDeviation[QValueOffset] = abs(QSorted[QValueOffset] - QValueCenter);
}
QInsertionSort(QDeviation, 64);
QValueMAD = (QDeviation[31] + QDeviation[32]) / 2.;
if (QValueMAD < 1.e-15 || QValueInterquartile < 1.e-15)
{
return 0;
}
QValueNow = QCurveHistory[0];
QValueLess = 0;
QValueEqual = 0;
for (QValueOffset = 0; QValueOffset < 64; QValueOffset++)
{
if (QSorted[QValueOffset] < QValueNow)
{
QValueLess++;
}
if (QSorted[QValueOffset] == QValueNow)
{
QValueEqual++;
}
}
QPercentile = (QValueLess + QValueEqual * 0.5) / 64.;
QRobustScore = (QValueNow - QValueCenter) / (1.4826 * QValueMAD);
// High long-minus-short curve slope means near returns lag: fade the distortion.
// Require a turn back toward the historical center, not just an extreme level.
if (QPercentile > 0.9 && QRobustScore > 1.5 && QValueNow < QCurveHistory[1])
{
return 1;
}
if (QPercentile < 0.1 && QRobustScore < -1.5 && QValueNow > QCurveHistory[1])
{
return -1;
}
return 0;
}
void QCheckRobustness()
{
int I, Original, Reversed, Fail;
var Medians[5];
Fail = 0;
Medians[0] = 4.;
Medians[1] = 2.;
Medians[2] = 5.;
Medians[3] = 1.;
Medians[4] = 3.;
QInsertionSort(Medians, 5);
if (Medians[2] != 3.)
{
Fail++;
}
for (I = 0; I < 120; I++)
{
QPrice[I] = 1.;
}
if (QEstimateShape() != 0)
{
Fail++;
}
for (I = 0; I < 120; I++)
{
QPrice[I] = exp(0.003 * cos(0.23 * I) + 0.0007 * sin(0.87 * I));
}
Original = QEstimateShape();
for (I = 0; I < 120; I++)
{
QPrice[I] = 1. / QPrice[I];
}
Reversed = QEstimateShape();
if (Original != -Reversed)
{
Fail++;
}
QPrice[6] = 0.;
if (QEstimateShape() != 0)
{
Fail++;
}
file_write("Log/TS10_RobustQuantileCurve_test.txt", strf("4 checks; %d failures\n", Fail), 0);
}
var QHistoricalQuantile(var Probability)
{
var Index, Fraction;
int Lower;
if (Probability < 0. || Probability > 1.)
{
return 0.;
}
Index = 63. * Probability;
Lower = (int)floor(Index);
if (Lower >= 63)
{
return QSorted[63];
}
Fraction = Index - Lower;
return QSorted[Lower] * (1. - Fraction) + QSorted[Lower + 1] * Fraction;
}
var QBowleyAsymmetry()
{
var Low, Mid, High;
Low = QHistoricalQuantile(0.25);
Mid = QHistoricalQuantile(0.5);
High = QHistoricalQuantile(0.75);
if (High - Low < 1.e-20)
{
return 0.;
}
return (High + Low - 2. * Mid) / (High - Low);
}
var QInterdecileWidth()
{
return QHistoricalQuantile(0.9) - QHistoricalQuantile(0.1);
}
var QMedianSuccessiveDifference()
{
var Changes[64];
int At;
for (At = 0; At < 64; At++)
{
Changes[At] = abs(QCurveHistory[At] - QCurveHistory[At + 1]);
}
QInsertionSort(Changes, 64);
return (Changes[31] + Changes[32]) / 2.;
}
void QResearchDiagnostics()
{
printf("\nQuantile rank %.6g; Bowley asymmetry %.6g", QPercentile, QBowleyAsymmetry());
printf("\nQuantile interdecile width %.6g; median successive change %.6g", QInterdecileWidth(),
QMedianSuccessiveDifference());
}
// ============================================================================
// EXTENDED REGRESSION SUITE: deterministic properties over market regimes
// These functions run ONLY under STX_SELFTEST; they never place orders.
// ============================================================================
int QExtendedCount = 0;
int QExtendedFailures = 0;
void QExpect(int Passed, string Description)
{
QExtendedCount++;
if (!Passed)
{
QExtendedFailures++;
file_append("Log/TS10_RobustQuantileCurve_extended.txt", strf("FAIL: %s\n", Description));
}
}
void QCase_quiet_cycle()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 120; K++)
{
QPrice[K] = 1.0 * exp(0.0005 * sin(0.17 * K));
}
Original = QEstimateShape();
QExpect(Original >= -1 && Original <= 1, "quiet_cycle: bounded direction");
Again = QEstimateShape();
QExpect(Again == Original, "quiet_cycle: repeatable estimate");
for (K = 0; K < 120; K++)
{
QPrice[K] *= 7.;
}
Scaled = QEstimateShape();
QExpect(Scaled == Original, "quiet_cycle: price-unit invariance");
for (K = 0; K < 120; K++)
{
QPrice[K] = 1. / QPrice[K];
}
Reflected = QEstimateShape();
QExpect(Reflected == -Original, "quiet_cycle: directional reflection");
QPrice[60] = 0.;
QExpect(QEstimateShape() == 0, "quiet_cycle: missing price rejected");
}
void QCase_mixed_cycles()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 120; K++)
{
QPrice[K] = 1.0 * exp(0.003 * sin(0.23 * K) + 0.0007 * cos(0.81 * K));
}
Original = QEstimateShape();
QExpect(Original >= -1 && Original <= 1, "mixed_cycles: bounded direction");
Again = QEstimateShape();
QExpect(Again == Original, "mixed_cycles: repeatable estimate");
for (K = 0; K < 120; K++)
{
QPrice[K] *= 7.;
}
Scaled = QEstimateShape();
QExpect(Scaled == Original, "mixed_cycles: price-unit invariance");
for (K = 0; K < 120; K++)
{
QPrice[K] = 1. / QPrice[K];
}
Reflected = QEstimateShape();
QExpect(Reflected == -Original, "mixed_cycles: directional reflection");
QPrice[60] = 0.;
QExpect(QEstimateShape() == 0, "mixed_cycles: missing price rejected");
}
void QCase_persistent_upward()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 120; K++)
{
QPrice[K] = 1.0 * exp(-0.001 * K + 0.0001 * sin(0.53 * K));
}
Original = QEstimateShape();
QExpect(Original >= -1 && Original <= 1, "persistent_upward: bounded direction");
Again = QEstimateShape();
QExpect(Again == Original, "persistent_upward: repeatable estimate");
for (K = 0; K < 120; K++)
{
QPrice[K] *= 7.;
}
Scaled = QEstimateShape();
QExpect(Scaled == Original, "persistent_upward: price-unit invariance");
for (K = 0; K < 120; K++)
{
QPrice[K] = 1. / QPrice[K];
}
Reflected = QEstimateShape();
QExpect(Reflected == -Original, "persistent_upward: directional reflection");
QPrice[60] = 0.;
QExpect(QEstimateShape() == 0, "persistent_upward: missing price rejected");
}
void QCase_persistent_downward()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 120; K++)
{
QPrice[K] = 1.0 * exp(0.001 * K + 0.0001 * cos(0.47 * K));
}
Original = QEstimateShape();
QExpect(Original >= -1 && Original <= 1, "persistent_downward: bounded direction");
Again = QEstimateShape();
QExpect(Again == Original, "persistent_downward: repeatable estimate");
for (K = 0; K < 120; K++)
{
QPrice[K] *= 7.;
}
Scaled = QEstimateShape();
QExpect(Scaled == Original, "persistent_downward: price-unit invariance");
for (K = 0; K < 120; K++)
{
QPrice[K] = 1. / QPrice[K];
}
Reflected = QEstimateShape();
QExpect(Reflected == -Original, "persistent_downward: directional reflection");
QPrice[60] = 0.;
QExpect(QEstimateShape() == 0, "persistent_downward: missing price rejected");
}
void QCase_slow_curve()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 120; K++)
{
QPrice[K] = 1.0 * exp(0.004 * cos(0.08 * K) + 0.0002 * sin(0.7 * K));
}
Original = QEstimateShape();
QExpect(Original >= -1 && Original <= 1, "slow_curve: bounded direction");
Again = QEstimateShape();
QExpect(Again == Original, "slow_curve: repeatable estimate");
for (K = 0; K < 120; K++)
{
QPrice[K] *= 7.;
}
Scaled = QEstimateShape();
QExpect(Scaled == Original, "slow_curve: price-unit invariance");
for (K = 0; K < 120; K++)
{
QPrice[K] = 1. / QPrice[K];
}
Reflected = QEstimateShape();
QExpect(Reflected == -Original, "slow_curve: directional reflection");
QPrice[60] = 0.;
QExpect(QEstimateShape() == 0, "slow_curve: missing price rejected");
}
void QCase_rough_curve()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 120; K++)
{
QPrice[K] = 1.0 * exp(0.001 * sin(1.7 * K) + 0.0005 * cos(2.3 * K));
}
Original = QEstimateShape();
QExpect(Original >= -1 && Original <= 1, "rough_curve: bounded direction");
Again = QEstimateShape();
QExpect(Again == Original, "rough_curve: repeatable estimate");
for (K = 0; K < 120; K++)
{
QPrice[K] *= 7.;
}
Scaled = QEstimateShape();
QExpect(Scaled == Original, "rough_curve: price-unit invariance");
for (K = 0; K < 120; K++)
{
QPrice[K] = 1. / QPrice[K];
}
Reflected = QEstimateShape();
QExpect(Reflected == -Original, "rough_curve: directional reflection");
QPrice[60] = 0.;
QExpect(QEstimateShape() == 0, "rough_curve: missing price rejected");
}
void QCase_accelerating_path()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 120; K++)
{
QPrice[K] = 1.0 * exp(-0.0001 * K - 0.000002 * K * K + 0.0002 * sin(0.41 * K));
}
Original = QEstimateShape();
QExpect(Original >= -1 && Original <= 1, "accelerating_path: bounded direction");
Again = QEstimateShape();
QExpect(Again == Original, "accelerating_path: repeatable estimate");
for (K = 0; K < 120; K++)
{
QPrice[K] *= 7.;
}
Scaled = QEstimateShape();
QExpect(Scaled == Original, "accelerating_path: price-unit invariance");
for (K = 0; K < 120; K++)
{
QPrice[K] = 1. / QPrice[K];
}
Reflected = QEstimateShape();
QExpect(Reflected == -Original, "accelerating_path: directional reflection");
QPrice[60] = 0.;
QExpect(QEstimateShape() == 0, "accelerating_path: missing price rejected");
}
void QCase_decelerating_path()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 120; K++)
{
QPrice[K] = 1.0 * exp(-0.0008 * K + 0.000002 * K * K + 0.0002 * cos(0.31 * K));
}
Original = QEstimateShape();
QExpect(Original >= -1 && Original <= 1, "decelerating_path: bounded direction");
Again = QEstimateShape();
QExpect(Again == Original, "decelerating_path: repeatable estimate");
for (K = 0; K < 120; K++)
{
QPrice[K] *= 7.;
}
Scaled = QEstimateShape();
QExpect(Scaled == Original, "decelerating_path: price-unit invariance");
for (K = 0; K < 120; K++)
{
QPrice[K] = 1. / QPrice[K];
}
Reflected = QEstimateShape();
QExpect(Reflected == -Original, "decelerating_path: directional reflection");
QPrice[60] = 0.;
QExpect(QEstimateShape() == 0, "decelerating_path: missing price rejected");
}
void QCase_volatility_ramp()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 120; K++)
{
QPrice[K] = 1.0 * exp((0.0001 + K * 0.00001) * sin(0.37 * K));
}
Original = QEstimateShape();
QExpect(Original >= -1 && Original <= 1, "volatility_ramp: bounded direction");
Again = QEstimateShape();
QExpect(Again == Original, "volatility_ramp: repeatable estimate");
for (K = 0; K < 120; K++)
{
QPrice[K] *= 7.;
}
Scaled = QEstimateShape();
QExpect(Scaled == Original, "volatility_ramp: price-unit invariance");
for (K = 0; K < 120; K++)
{
QPrice[K] = 1. / QPrice[K];
}
Reflected = QEstimateShape();
QExpect(Reflected == -Original, "volatility_ramp: directional reflection");
QPrice[60] = 0.;
QExpect(QEstimateShape() == 0, "volatility_ramp: missing price rejected");
}
void QCase_volatility_decay()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 120; K++)
{
QPrice[K] = 1.0 * exp(0.006 * exp(-0.02 * K) * cos(0.7 * K));
}
Original = QEstimateShape();
QExpect(Original >= -1 && Original <= 1, "volatility_decay: bounded direction");
Again = QEstimateShape();
QExpect(Again == Original, "volatility_decay: repeatable estimate");
for (K = 0; K < 120; K++)
{
QPrice[K] *= 7.;
}
Scaled = QEstimateShape();
QExpect(Scaled == Original, "volatility_decay: price-unit invariance");
for (K = 0; K < 120; K++)
{
QPrice[K] = 1. / QPrice[K];
}
Reflected = QEstimateShape();
QExpect(Reflected == -Original, "volatility_decay: directional reflection");
QPrice[60] = 0.;
QExpect(QEstimateShape() == 0, "volatility_decay: missing price rejected");
}
void QCase_cycle_with_drift()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 120; K++)
{
QPrice[K] = 1.0 * exp(-0.0002 * K + 0.003 * sin(0.19 * K) + 0.0005 * cos(0.61 * K));
}
Original = QEstimateShape();
QExpect(Original >= -1 && Original <= 1, "cycle_with_drift: bounded direction");
Again = QEstimateShape();
QExpect(Again == Original, "cycle_with_drift: repeatable estimate");
for (K = 0; K < 120; K++)
{
QPrice[K] *= 7.;
}
Scaled = QEstimateShape();
QExpect(Scaled == Original, "cycle_with_drift: price-unit invariance");
for (K = 0; K < 120; K++)
{
QPrice[K] = 1. / QPrice[K];
}
Reflected = QEstimateShape();
QExpect(Reflected == -Original, "cycle_with_drift: directional reflection");
QPrice[60] = 0.;
QExpect(QEstimateShape() == 0, "cycle_with_drift: missing price rejected");
}
void QCase_near_zero_prices()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 120; K++)
{
QPrice[K] = 0.0001 * exp(0.002 * sin(0.29 * K) + 0.001 * cos(0.13 * K));
}
Original = QEstimateShape();
QExpect(Original >= -1 && Original <= 1, "near_zero_prices: bounded direction");
Again = QEstimateShape();
QExpect(Again == Original, "near_zero_prices: repeatable estimate");
for (K = 0; K < 120; K++)
{
QPrice[K] *= 7.;
}
Scaled = QEstimateShape();
QExpect(Scaled == Original, "near_zero_prices: price-unit invariance");
for (K = 0; K < 120; K++)
{
QPrice[K] = 1. / QPrice[K];
}
Reflected = QEstimateShape();
QExpect(Reflected == -Original, "near_zero_prices: directional reflection");
QPrice[60] = 0.;
QExpect(QEstimateShape() == 0, "near_zero_prices: missing price rejected");
}
void QCase_large_price_units()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 120; K++)
{
QPrice[K] = 10000.0 * exp(0.003 * sin(0.11 * K) + 0.0008 * cos(0.43 * K));
}
Original = QEstimateShape();
QExpect(Original >= -1 && Original <= 1, "large_price_units: bounded direction");
Again = QEstimateShape();
QExpect(Again == Original, "large_price_units: repeatable estimate");
for (K = 0; K < 120; K++)
{
QPrice[K] *= 7.;
}
Scaled = QEstimateShape();
QExpect(Scaled == Original, "large_price_units: price-unit invariance");
for (K = 0; K < 120; K++)
{
QPrice[K] = 1. / QPrice[K];
}
Reflected = QEstimateShape();
QExpect(Reflected == -Original, "large_price_units: directional reflection");
QPrice[60] = 0.;
QExpect(QEstimateShape() == 0, "large_price_units: missing price rejected");
}
void QCase_high_frequency_chop()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 120; K++)
{
QPrice[K] = 1.0 * exp(0.0008 * cos(2.8 * K) + 0.001 * sin(0.23 * K));
}
Original = QEstimateShape();
QExpect(Original >= -1 && Original <= 1, "high_frequency_chop: bounded direction");
Again = QEstimateShape();
QExpect(Again == Original, "high_frequency_chop: repeatable estimate");
for (K = 0; K < 120; K++)
{
QPrice[K] *= 7.;
}
Scaled = QEstimateShape();
QExpect(Scaled == Original, "high_frequency_chop: price-unit invariance");
for (K = 0; K < 120; K++)
{
QPrice[K] = 1. / QPrice[K];
}
Reflected = QEstimateShape();
QExpect(Reflected == -Original, "high_frequency_chop: directional reflection");
QPrice[60] = 0.;
QExpect(QEstimateShape() == 0, "high_frequency_chop: missing price rejected");
}
void QCase_long_wave_trend()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 120; K++)
{
QPrice[K] = 1.0 * exp(-0.0005 * K + 0.002 * cos(0.07 * K));
}
Original = QEstimateShape();
QExpect(Original >= -1 && Original <= 1, "long_wave_trend: bounded direction");
Again = QEstimateShape();
QExpect(Again == Original, "long_wave_trend: repeatable estimate");
for (K = 0; K < 120; K++)
{
QPrice[K] *= 7.;
}
Scaled = QEstimateShape();
QExpect(Scaled == Original, "long_wave_trend: price-unit invariance");
for (K = 0; K < 120; K++)
{
QPrice[K] = 1. / QPrice[K];
}
Reflected = QEstimateShape();
QExpect(Reflected == -Original, "long_wave_trend: directional reflection");
QPrice[60] = 0.;
QExpect(QEstimateShape() == 0, "long_wave_trend: missing price rejected");
}
void QCase_opposing_scales()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 120; K++)
{
QPrice[K] = 1.0 * exp(0.005 * sin(0.09 * K) - 0.002 * sin(0.59 * K));
}
Original = QEstimateShape();
QExpect(Original >= -1 && Original <= 1, "opposing_scales: bounded direction");
Again = QEstimateShape();
QExpect(Again == Original, "opposing_scales: repeatable estimate");
for (K = 0; K < 120; K++)
{
QPrice[K] *= 7.;
}
Scaled = QEstimateShape();
QExpect(Scaled == Original, "opposing_scales: price-unit invariance");
for (K = 0; K < 120; K++)
{
QPrice[K] = 1. / QPrice[K];
}
Reflected = QEstimateShape();
QExpect(Reflected == -Original, "opposing_scales: directional reflection");
QPrice[60] = 0.;
QExpect(QEstimateShape() == 0, "opposing_scales: missing price rejected");
}
void QCase_nonlinear_curve()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 120; K++)
{
QPrice[K] = 1.0 * exp(0.002 * sin(0.021 * K * K) + 0.001 * cos(0.33 * K));
}
Original = QEstimateShape();
QExpect(Original >= -1 && Original <= 1, "nonlinear_curve: bounded direction");
Again = QEstimateShape();
QExpect(Again == Original, "nonlinear_curve: repeatable estimate");
for (K = 0; K < 120; K++)
{
QPrice[K] *= 7.;
}
Scaled = QEstimateShape();
QExpect(Scaled == Original, "nonlinear_curve: price-unit invariance");
for (K = 0; K < 120; K++)
{
QPrice[K] = 1. / QPrice[K];
}
Reflected = QEstimateShape();
QExpect(Reflected == -Original, "nonlinear_curve: directional reflection");
QPrice[60] = 0.;
QExpect(QEstimateShape() == 0, "nonlinear_curve: missing price rejected");
}
void QCase_amplitude_modulation()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 120; K++)
{
QPrice[K] = 1.0 * exp(0.002 * sin(0.3 * K) * cos(0.04 * K));
}
Original = QEstimateShape();
QExpect(Original >= -1 && Original <= 1, "amplitude_modulation: bounded direction");
Again = QEstimateShape();
QExpect(Again == Original, "amplitude_modulation: repeatable estimate");
for (K = 0; K < 120; K++)
{
QPrice[K] *= 7.;
}
Scaled = QEstimateShape();
QExpect(Scaled == Original, "amplitude_modulation: price-unit invariance");
for (K = 0; K < 120; K++)
{
QPrice[K] = 1. / QPrice[K];
}
Reflected = QEstimateShape();
QExpect(Reflected == -Original, "amplitude_modulation: directional reflection");
QPrice[60] = 0.;
QExpect(QEstimateShape() == 0, "amplitude_modulation: missing price rejected");
}
void QCase_decaying_event()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 120; K++)
{
QPrice[K] = 1.0 * exp(0.01 * exp(-0.2 * K) + 0.0003 * sin(0.71 * K));
}
Original = QEstimateShape();
QExpect(Original >= -1 && Original <= 1, "decaying_event: bounded direction");
Again = QEstimateShape();
QExpect(Again == Original, "decaying_event: repeatable estimate");
for (K = 0; K < 120; K++)
{
QPrice[K] *= 7.;
}
Scaled = QEstimateShape();
QExpect(Scaled == Original, "decaying_event: price-unit invariance");
for (K = 0; K < 120; K++)
{
QPrice[K] = 1. / QPrice[K];
}
Reflected = QEstimateShape();
QExpect(Reflected == -Original, "decaying_event: directional reflection");
QPrice[60] = 0.;
QExpect(QEstimateShape() == 0, "decaying_event: missing price rejected");
}
void QCase_time_varying_frequency()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 120; K++)
{
QPrice[K] = 1.0 * exp(0.002 * cos(0.004 * K * K + 0.11 * K));
}
Original = QEstimateShape();
QExpect(Original >= -1 && Original <= 1, "time_varying_frequency: bounded direction");
Again = QEstimateShape();
QExpect(Again == Original, "time_varying_frequency: repeatable estimate");
for (K = 0; K < 120; K++)
{
QPrice[K] *= 7.;
}
Scaled = QEstimateShape();
QExpect(Scaled == Original, "time_varying_frequency: price-unit invariance");
for (K = 0; K < 120; K++)
{
QPrice[K] = 1. / QPrice[K];
}
Reflected = QEstimateShape();
QExpect(Reflected == -Original, "time_varying_frequency: directional reflection");
QPrice[60] = 0.;
QExpect(QEstimateShape() == 0, "time_varying_frequency: missing price rejected");
}
void QCase_slow_fast_cancellation()
{
int K, Original, Again, Scaled, Reflected;
for (K = 0; K < 120; K++)
{
QPrice[K] = 1.0 * exp(0.004 * sin(0.07 * K) + 0.0013 * cos(0.97 * K));
}
Original = QEstimateShape();
QExpect(Original >= -1 && Original <= 1, "slow_fast_cancellation: bounded direction");
Again = QEstimateShape();
QExpect(Again == Original, "slow_fast_cancellation: repeatable estimate");
for (K = 0; K < 120; K++)
{
QPrice[K] *= 7.;
}
Scaled = QEstimateShape();
QExpect(Scaled == Original, "slow_fast_cancellation: price-unit invariance");
for (K = 0; K < 120; K++)
{
QPrice[K] = 1. / QPrice[K];
}
Reflected = QEstimateShape();
QExpect(Reflected == -Original, "slow_fast_cancellation: directional reflection");
QPrice[60] = 0.;
QExpect(QEstimateShape() == 0, "slow_fast_cancellation: missing price rejected");
}
void QExtendedTests()
{
QExtendedCount = 0;
QExtendedFailures = 0;
file_write("Log/TS10_RobustQuantileCurve_extended.txt",
"TS10_RobustQuantileCurve: extended properties\n", 0);
QCase_quiet_cycle();
QCase_mixed_cycles();
QCase_persistent_upward();
QCase_persistent_downward();
QCase_slow_curve();
QCase_rough_curve();
QCase_accelerating_path();
QCase_decelerating_path();
QCase_volatility_ramp();
QCase_volatility_decay();
QCase_cycle_with_drift();
QCase_near_zero_prices();
QCase_large_price_units();
QCase_high_frequency_chop();
QCase_long_wave_trend();
QCase_opposing_scales();
QCase_nonlinear_curve();
QCase_amplitude_modulation();
QCase_decaying_event();
QCase_time_varying_frequency();
QCase_slow_fast_cancellation();
file_append("Log/TS10_RobustQuantileCurve_extended.txt",
strf("RESULT: %d checks; %d failures\n", QExtendedCount, QExtendedFailures));
}
function run()
{
#ifdef STX_SELFTEST
if (is(INITRUN))
{
QCheckRobustness();
QExtendedTests();
quit("Quantile tests complete");
}
return;
#endif
int I, Distortion;
var AmountAllowed, CashLoss;
BarPeriod = 60;
LookBack = 121;
Capital = 10000.;
StartDate = 20240101;
EndDate = 20241231;
Hedge = 0;
MaxLong = 1;
MaxShort = 1;
if (!asset("EUR/USD"))
{
return;
}
algo("Q10");
if (is(EXITRUN))
{
QResearchDiagnostics();
return;
}
if (is(LOOKBACK))
{
return;
}
for (I = 0; I < 120; I++)
{
QPrice[I] = priceClose(I + 1);
}
Distortion = QEstimateShape();
if (abs(QRobustScore) < 0.3 || (QPercentile > 0.4 && QPercentile < 0.6))
{
exitLong();
exitShort();
}
if (Distortion == 0 || NumOpenLong + NumOpenShort > 0)
{
return;
}
if (Balance <= 0. || Equity < Balance * 0.85)
{
return;
}
if (LotAmount <= 0. || PIPCost <= 0. || MarginCost <= 0. || PIP <= 0.)
{
return;
}
Stop = 35. * PIP;
TakeProfit = 60. * PIP;
LifeTime = 12;
CashLoss = (Stop + Spread) * PIPCost / PIP + Commission * LotAmount / 10000.;
if (CashLoss <= 0.)
{
return;
}
AmountAllowed = min(Balance * 0.005 / CashLoss, 2000. / LotAmount);
AmountAllowed = min(AmountAllowed, max(0., Equity - MarginVal) * 0.8 / MarginCost);
if (AmountAllowed < 1.)
{
return;
}
Lots = floor(AmountAllowed);
Margin = 0.;
Risk = 0.;
if (Distortion > 0)
{
enterLong();
}
else
{
enterShort();
}
}
|
|
|
Harmonic Phase Forecast
[Re: TipmyPip]
#489735
11 hours ago
11 hours ago
|
Joined: Sep 2017
Posts: 355
TipmyPip
OP
Senior Member
|
OP
Senior Member
Joined: Sep 2017
Posts: 355
|
Harmonic Phase Forecast This strategy asks whether a coherent oscillatory component in recent returns can support a directional forecast over several future holding horizons. It does not estimate covariance eigenvectors, split a signal into Haar energy bands, or fit a latent Kalman curve. Its analytical object is the phase of a small family of sinusoidal components. This is a different hypothesis from saying that a market is generally trending: an otherwise stationary cycle can produce a positive forecast during one phase and a negative forecast during another. The model takes 96 completed returns and reverses their indexing internally to obtain chronological observations x[t]. It computes mean = sum(x[t])/96 and noise = sum((x[t]-mean)^2)/96. For each frequency index k from 1 through 24, it evaluates a[k] = sum((x[t]-mean)*cos(2*pi*k*t/96))/48 and b[k] = sum((x[t]-mean)*sin(2*pi*k*t/96))/48. Component power is power[k] = a[k]^2 + b[k]^2. The selected frequency maximizes that power within the inspected range. A constant nonzero return sequence has a separate bounded-drift branch because its demeaned spectral energy vanishes. Rather than extrapolating a single winning bin without qualification, the forecast combines that bin with its immediate valid neighbors. Each receives a weight proportional to its observed power. For future step h, the component projection is a[k]*cos(2*pi*k*(95+h)/96) + b[k]*sin(2*pi*k*(95+h)/96). Adding the sample mean gives forecast[h]. These projections are averaged over horizons 2, 6, and 12. The final return estimate uses weights 4, 2, and 1 on those averages. Consequently, short-horizon phase receives greater influence than the longest extrapolation. Quality combines spectral concentration with agreement across the forecast horizons. In symbols, concentration = max(power)/sum(power) and quality = concentration/(1 + disagreement/sqrt(noise)). Disagreement is the absolute difference between adjacent horizon averages. The signed edge is the combined forecast divided by sqrt(noise + forecast^2). A low-quality estimate abstains before the shared execution gates are considered. The maximum holding period is twelve hourly bars, and phase deterioration can exit an existing position sooner. The principal weakness is nonstationarity. Selecting a dominant frequency in the same window used for estimation is not out-of-sample validation. Spectral leakage, changing cycle lengths, abrupt news, and aliasing can make a numerically clean phase projection economically useless. The embedded tests check numerical contracts and directional reflection under varied synthetic paths. They do not show that Fourier extrapolation beats trading costs, and they do not establish that this strategy diversifies the other nine in actual returns. A useful future evaluation should track frequency turnover, phase forecast error, signal coverage, and performance separately during quiet and rapidly changing volatility regimes. // TS11_HarmonicPhase: Harmonic phase forecast.
// 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: dominant discrete frequency.
// Quality heuristic: Spectral concentration and forecast-horizon disagreement.
// Limitation: Frequency selection is in-sample. Spectral leakage and phase changes can invalidate continuation.
// 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 = "TS11";
string TS2TestLog = "Log/TS11_HarmonicPhase_test.txt";
int TS2Holding = 12;
// 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
// Fit orthogonal harmonics to returns, not wavelet energies or PCA factors.
// Chronology is reversed for the DFT so that the forecast lies after the sample.
var TS2Model()
{
var Real[25], Imaginary[25], Power[25];
var Total, Best, Mean, Angle, Forecast, Noise, Coherence, Weight;
var Fast, Medium, Slow, Disagreement, Numerator, Denominator;
int Frequency, Time, Winner, Horizon;
Mean = 0.;
Noise = 0.;
for (Time = 0; Time < 96; Time++)
Mean += TS2Returns[Time] / 96.;
for (Time = 0; Time < 96; Time++)
Noise += pow(TS2Returns[Time] - Mean, 2.) / 96.;
if (Noise < 1.e-22)
{
TS2Quality = 1.;
return TS2Bound(Mean / sqrt(Mean * Mean + 1.e-22));
}
Total = 0.;
Best = 0.;
Winner = 1;
for (Frequency = 1; Frequency <= 24; Frequency++)
{
Real[Frequency] = 0.;
Imaginary[Frequency] = 0.;
for (Time = 0; Time < 96; Time++)
{
Angle = 6.283185307179586 * Frequency * Time / 96.;
Real[Frequency] += (TS2Returns[95 - Time] - Mean) * cos(Angle) / 48.;
Imaginary[Frequency] += (TS2Returns[95 - Time] - Mean) * sin(Angle) / 48.;
}
Power[Frequency] = Real[Frequency] * Real[Frequency];
Power[Frequency] += Imaginary[Frequency] * Imaginary[Frequency];
Total += Power[Frequency];
if (Power[Frequency] > Best)
{
Best = Power[Frequency];
Winner = Frequency;
}
}
if (Total < 1.e-22)
return 0.;
Coherence = Best / Total;
Fast = 0.;
Medium = 0.;
Slow = 0.;
// Local frequency neighborhood reduces sensitivity to a single FFT bin.
for (Horizon = 1; Horizon <= 12; Horizon++)
{
Numerator = 0.;
Denominator = 0.;
for (Frequency = max(1, Winner - 1); Frequency <= min(24, Winner + 1); Frequency++)
{
Weight = Power[Frequency] / Total;
Angle = 6.283185307179586 * Frequency * (95 + Horizon) / 96.;
Numerator += Weight * (Real[Frequency] * cos(Angle) + Imaginary[Frequency] * sin(Angle));
Denominator += Weight;
}
Forecast = Mean + Numerator / max(1.e-22, Denominator);
if (Horizon <= 2)
Fast += Forecast / 2.;
if (Horizon <= 6)
Medium += Forecast / 6.;
Slow += Forecast / 12.;
}
Disagreement = abs(Fast - Medium) + abs(Medium - Slow);
TS2Statistic = Winner;
TS2Quality = Coherence / (1. + Disagreement / sqrt(Noise));
if (TS2Quality < 0.20)
return 0.;
Forecast = (4. * Fast + 2. * Medium + Slow) / 7.;
return Forecast / sqrt(Noise + Forecast * Forecast);
}
// 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.99, "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 11 perturbation phase 1.507000.
// 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.507000 + I * 0.333000);
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[11] = 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 11 perturbation phase 1.507000.
// 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.507000 + I * 0.333000);
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[48] = 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 11 perturbation phase 1.507000.
// 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.507000 + I * 0.333000);
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[85] = 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 11 perturbation phase 1.507000.
// 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.507000 + I * 0.333000);
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[122] = 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 11 perturbation phase 1.507000.
// 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.507000 + I * 0.333000);
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[159] = 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 11 perturbation phase 1.507000.
// 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.507000 + I * 0.333000);
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[196] = 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 11 perturbation phase 1.507000.
// 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.507000 + I * 0.333000);
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[233] = 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 11 perturbation phase 1.507000.
// 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.507000 + I * 0.333000);
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[14] = 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 11 perturbation phase 1.507000.
// 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.507000 + I * 0.333000);
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[51] = 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 11 perturbation phase 1.507000.
// 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.507000 + I * 0.333000);
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[88] = 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 11 perturbation phase 1.507000.
// 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.507000 + I * 0.333000);
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[125] = 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 11 perturbation phase 1.507000.
// 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.507000 + I * 0.333000);
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[162] = 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 11 perturbation phase 1.507000.
// 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.507000 + I * 0.333000);
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[199] = 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 11 perturbation phase 1.507000.
// 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.507000 + I * 0.333000);
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[236] = 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 11 perturbation phase 1.507000.
// 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.507000 + I * 0.333000);
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[17] = 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 11 perturbation phase 1.507000.
// 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.507000 + I * 0.333000);
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[54] = 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 11 perturbation phase 1.507000.
// 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.507000 + I * 0.333000);
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[91] = 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 11 perturbation phase 1.507000.
// 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.507000 + I * 0.333000);
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[128] = 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 11 perturbation phase 1.507000.
// 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.507000 + I * 0.333000);
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[165] = 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 11 perturbation phase 1.507000.
// 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.507000 + I * 0.333000);
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[202] = 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 11 perturbation phase 1.507000.
// 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.507000 + I * 0.333000);
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[239] = 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 11 perturbation phase 1.507000.
// 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.507000 + I * 0.333000);
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[20] = 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 11 perturbation phase 1.507000.
// 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.507000 + I * 0.333000);
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[57] = 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 11 perturbation phase 1.507000.
// 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.507000 + I * 0.333000);
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[94] = 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 11 perturbation phase 1.507000.
// 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.507000 + I * 0.333000);
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[131] = 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 11 perturbation phase 1.507000.
// 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.507000 + I * 0.333000);
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[168] = 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 11 perturbation phase 1.507000.
// 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.507000 + I * 0.333000);
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: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[205] = 2.;
TS2Expect(TS2Evaluate() == 0., "clustered_down_events: implausible return rejected");
TS2Expect(TS2Quality == 0., "clustered_down_events: rejected sample clears quality");
for (I =
Last edited by TipmyPip; 10 hours ago.
|
|
|
Harmonic Phase Forecast (cont.)
[Re: TipmyPip]
#489736
11 hours ago
11 hours ago
|
Joined: Sep 2017
Posts: 355
TipmyPip
OP
Senior Member
|
OP
Senior Member
Joined: Sep 2017
Posts: 355
|
// Case 27: clustered_down_events; model 11 perturbation phase 1.507000.
// 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.507000 + I * 0.333000);
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: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[205] = 2.;
TS2Expect(TS2Evaluate() == 0., "clustered_down_events: implausible return rejected");
TS2Expect(TS2Quality == 0., "clustered_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, "clustered_down_events: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "clustered_down_events: quality restored");
}
// Case 28: capped_sawtooth; model 11 perturbation phase 1.507000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case28()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = 0.00012 * ((I % 19) - 9);
TS2Returns[I] += 0.00000003 * sin(1.507000 + I * 0.333000);
Snapshot[I] = TS2Returns[I];
}
Original = TS2Evaluate();
InitialQuality = TS2Quality;
InitialStatistic = TS2Statistic;
TS2Expect(Original == Original && abs(Original) <= 1., "capped_sawtooth: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "capped_sawtooth: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "capped_sawtooth: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "capped_sawtooth: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "capped_sawtooth: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "capped_sawtooth: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[242] = 2.;
TS2Expect(TS2Evaluate() == 0., "capped_sawtooth: implausible return rejected");
TS2Expect(TS2Quality == 0., "capped_sawtooth: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "capped_sawtooth: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "capped_sawtooth: quality restored");
}
// Case 29: triangular_wave; model 11 perturbation phase 1.507000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case29()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = 0.00015 * (abs((I % 24) - 12) - 6);
TS2Returns[I] += 0.00000003 * sin(1.507000 + I * 0.333000);
Snapshot[I] = TS2Returns[I];
}
Original = TS2Evaluate();
InitialQuality = TS2Quality;
InitialStatistic = TS2Statistic;
TS2Expect(Original == Original && abs(Original) <= 1., "triangular_wave: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "triangular_wave: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "triangular_wave: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "triangular_wave: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "triangular_wave: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "triangular_wave: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[23] = 2.;
TS2Expect(TS2Evaluate() == 0., "triangular_wave: implausible return rejected");
TS2Expect(TS2Quality == 0., "triangular_wave: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "triangular_wave: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "triangular_wave: quality restored");
}
// Case 30: convex_drift; model 11 perturbation phase 1.507000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case30()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = 0.0001 + 0.001 * pow(I / 256., 2.);
TS2Returns[I] += 0.00000003 * sin(1.507000 + I * 0.333000);
Snapshot[I] = TS2Returns[I];
}
Original = TS2Evaluate();
InitialQuality = TS2Quality;
InitialStatistic = TS2Statistic;
TS2Expect(Original == Original && abs(Original) <= 1., "convex_drift: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "convex_drift: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "convex_drift: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "convex_drift: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "convex_drift: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "convex_drift: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[60] = 2.;
TS2Expect(TS2Evaluate() == 0., "convex_drift: implausible return rejected");
TS2Expect(TS2Quality == 0., "convex_drift: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "convex_drift: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "convex_drift: quality restored");
}
// Case 31: concave_drift; model 11 perturbation phase 1.507000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case31()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = 0.0011 - 0.001 * pow(I / 256., 2.);
TS2Returns[I] += 0.00000003 * sin(1.507000 + I * 0.333000);
Snapshot[I] = TS2Returns[I];
}
Original = TS2Evaluate();
InitialQuality = TS2Quality;
InitialStatistic = TS2Statistic;
TS2Expect(Original == Original && abs(Original) <= 1., "concave_drift: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "concave_drift: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "concave_drift: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "concave_drift: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "concave_drift: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "concave_drift: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[97] = 2.;
TS2Expect(TS2Evaluate() == 0., "concave_drift: implausible return rejected");
TS2Expect(TS2Quality == 0., "concave_drift: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "concave_drift: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "concave_drift: quality restored");
}
// Case 32: sigmoid_transition; model 11 perturbation phase 1.507000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case32()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = 0.001 * (2. / (1. + exp((I - 90.) / 12.)) - 1.);
TS2Returns[I] += 0.00000003 * sin(1.507000 + I * 0.333000);
Snapshot[I] = TS2Returns[I];
}
Original = TS2Evaluate();
InitialQuality = TS2Quality;
InitialStatistic = TS2Statistic;
TS2Expect(Original == Original && abs(Original) <= 1., "sigmoid_transition: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "sigmoid_transition: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "sigmoid_transition: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "sigmoid_transition: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "sigmoid_transition: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "sigmoid_transition: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[134] = 2.;
TS2Expect(TS2Evaluate() == 0., "sigmoid_transition: implausible return rejected");
TS2Expect(TS2Quality == 0., "sigmoid_transition: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "sigmoid_transition: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "sigmoid_transition: quality restored");
}
// Case 33: damped_oscillation; model 11 perturbation phase 1.507000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case33()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = 0.002 * exp(-0.012 * I) * cos(0.37 * I);
TS2Returns[I] += 0.00000003 * sin(1.507000 + I * 0.333000);
Snapshot[I] = TS2Returns[I];
}
Original = TS2Evaluate();
InitialQuality = TS2Quality;
InitialStatistic = TS2Statistic;
TS2Expect(Original == Original && abs(Original) <= 1., "damped_oscillation: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "damped_oscillation: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "damped_oscillation: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "damped_oscillation: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "damped_oscillation: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "damped_oscillation: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[171] = 2.;
TS2Expect(TS2Evaluate() == 0., "damped_oscillation: implausible return rejected");
TS2Expect(TS2Quality == 0., "damped_oscillation: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "damped_oscillation: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "damped_oscillation: quality restored");
}
// Case 34: growing_oscillation; model 11 perturbation phase 1.507000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case34()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = 0.0001 * exp(0.008 * I) * cos(0.37 * I);
TS2Returns[I] += 0.00000003 * sin(1.507000 + I * 0.333000);
Snapshot[I] = TS2Returns[I];
}
Original = TS2Evaluate();
InitialQuality = TS2Quality;
InitialStatistic = TS2Statistic;
TS2Expect(Original == Original && abs(Original) <= 1., "growing_oscillation: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "growing_oscillation: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "growing_oscillation: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "growing_oscillation: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "growing_oscillation: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "growing_oscillation: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[208] = 2.;
TS2Expect(TS2Evaluate() == 0., "growing_oscillation: implausible return rejected");
TS2Expect(TS2Quality == 0., "growing_oscillation: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "growing_oscillation: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "growing_oscillation: quality restored");
}
// Case 35: phase_discontinuity; model 11 perturbation phase 1.507000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case35()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = 0.001 * sin(0.3 * I + ifelse(I < 40, 1.5, 0.));
TS2Returns[I] += 0.00000003 * sin(1.507000 + I * 0.333000);
Snapshot[I] = TS2Returns[I];
}
Original = TS2Evaluate();
InitialQuality = TS2Quality;
InitialStatistic = TS2Statistic;
TS2Expect(Original == Original && abs(Original) <= 1., "phase_discontinuity: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "phase_discontinuity: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "phase_discontinuity: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "phase_discontinuity: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "phase_discontinuity: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "phase_discontinuity: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[245] = 2.;
TS2Expect(TS2Evaluate() == 0., "phase_discontinuity: implausible return rejected");
TS2Expect(TS2Quality == 0., "phase_discontinuity: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "phase_discontinuity: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "phase_discontinuity: quality restored");
}
// Case 36: frequency_discontinuity; model 11 perturbation phase 1.507000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case36()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = 0.001 * sin(ifelse(I < 80, 0.17, 0.63) * I);
TS2Returns[I] += 0.00000003 * sin(1.507000 + I * 0.333000);
Snapshot[I] = TS2Returns[I];
}
Original = TS2Evaluate();
InitialQuality = TS2Quality;
InitialStatistic = TS2Statistic;
TS2Expect(Original == Original && abs(Original) <= 1., "frequency_discontinuity: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "frequency_discontinuity: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "frequency_discontinuity: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "frequency_discontinuity: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "frequency_discontinuity: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "frequency_discontinuity: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[26] = 2.;
TS2Expect(TS2Evaluate() == 0., "frequency_discontinuity: implausible return rejected");
TS2Expect(TS2Quality == 0., "frequency_discontinuity: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "frequency_discontinuity: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "frequency_discontinuity: quality restored");
}
// Case 37: amplitude_discontinuity; model 11 perturbation phase 1.507000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case37()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = ifelse(I < 80, 0.002, 0.0003) * sin(0.4 * I);
TS2Returns[I] += 0.00000003 * sin(1.507000 + I * 0.333000);
Snapshot[I] = TS2Returns[I];
}
Original = TS2Evaluate();
InitialQuality = TS2Quality;
InitialStatistic = TS2Statistic;
TS2Expect(Original == Original && abs(Original) <= 1., "amplitude_discontinuity: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "amplitude_discontinuity: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "amplitude_discontinuity: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "amplitude_discontinuity: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "amplitude_discontinuity: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "amplitude_discontinuity: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[63] = 2.;
TS2Expect(TS2Evaluate() == 0., "amplitude_discontinuity: implausible return rejected");
TS2Expect(TS2Quality == 0., "amplitude_discontinuity: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "amplitude_discontinuity: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "amplitude_discontinuity: quality restored");
}
// Case 38: smooth_pulse; model 11 perturbation phase 1.507000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case38()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = 0.003 * exp(-pow((I - 32.) / 12., 2.)) - 0.0003;
TS2Returns[I] += 0.00000003 * sin(1.507000 + I * 0.333000);
Snapshot[I] = TS2Returns[I];
}
Original = TS2Evaluate();
InitialQuality = TS2Quality;
InitialStatistic = TS2Statistic;
TS2Expect(Original == Original && abs(Original) <= 1., "smooth_pulse: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "smooth_pulse: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "smooth_pulse: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "smooth_pulse: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "smooth_pulse: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "smooth_pulse: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[100] = 2.;
TS2Expect(TS2Evaluate() == 0., "smooth_pulse: implausible return rejected");
TS2Expect(TS2Quality == 0., "smooth_pulse: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "smooth_pulse: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "smooth_pulse: quality restored");
}
// Case 39: double_pulse; model 11 perturbation phase 1.507000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case39()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = 0.002 * exp(-pow((I - 16.) / 6., 2.)) - 0.002 * exp(-pow((I - 60.) / 9., 2.));
TS2Returns[I] += 0.00000003 * sin(1.507000 + I * 0.333000);
Snapshot[I] = TS2Returns[I];
}
Original = TS2Evaluate();
InitialQuality = TS2Quality;
InitialStatistic = TS2Statistic;
TS2Expect(Original == Original && abs(Original) <= 1., "double_pulse: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "double_pulse: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "double_pulse: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "double_pulse: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "double_pulse: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "double_pulse: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[137] = 2.;
TS2Expect(TS2Evaluate() == 0., "double_pulse: implausible return rejected");
TS2Expect(TS2Quality == 0., "double_pulse: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "double_pulse: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "double_pulse: quality restored");
}
// Case 40: cross_scale_conflict; model 11 perturbation phase 1.507000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case40()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = 0.0008 * cos(0.04 * I) - 0.001 * cos(0.6 * I);
TS2Returns[I] += 0.00000003 * sin(1.507000 + I * 0.333000);
Snapshot[I] = TS2Returns[I];
}
Original = TS2Evaluate();
InitialQuality = TS2Quality;
InitialStatistic = TS2Statistic;
TS2Expect(Original == Original && abs(Original) <= 1., "cross_scale_conflict: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "cross_scale_conflict: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "cross_scale_conflict: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "cross_scale_conflict: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "cross_scale_conflict: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "cross_scale_conflict: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[174] = 2.;
TS2Expect(TS2Evaluate() == 0., "cross_scale_conflict: implausible return rejected");
TS2Expect(TS2Quality == 0., "cross_scale_conflict: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "cross_scale_conflict: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "cross_scale_conflict: quality restored");
}
// Case 41: near_flat_noise; model 11 perturbation phase 1.507000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case41()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = 0.0000002 * sin(0.73 * I) + 0.0000001 * cos(0.29 * I);
TS2Returns[I] += 0.00000003 * sin(1.507000 + I * 0.333000);
Snapshot[I] = TS2Returns[I];
}
Original = TS2Evaluate();
InitialQuality = TS2Quality;
InitialStatistic = TS2Statistic;
TS2Expect(Original == Original && abs(Original) <= 1., "near_flat_noise: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "near_flat_noise: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "near_flat_noise: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "near_flat_noise: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "near_flat_noise: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "near_flat_noise: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[211] = 2.;
TS2Expect(TS2Evaluate() == 0., "near_flat_noise: implausible return rejected");
TS2Expect(TS2Quality == 0., "near_flat_noise: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "near_flat_noise: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "near_flat_noise: quality restored");
}
// Case 42: large_return_units; model 11 perturbation phase 1.507000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case42()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = 0.03 * sin(0.13 * I) + 0.01 * cos(0.7 * I);
TS2Returns[I] += 0.00000003 * sin(1.507000 + I * 0.333000);
Snapshot[I] = TS2Returns[I];
}
Original = TS2Evaluate();
InitialQuality = TS2Quality;
InitialStatistic = TS2Statistic;
TS2Expect(Original == Original && abs(Original) <= 1., "large_return_units: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "large_return_units: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "large_return_units: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "large_return_units: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "large_return_units: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "large_return_units: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[248] = 2.;
TS2Expect(TS2Evaluate() == 0., "large_return_units: implausible return rejected");
TS2Expect(TS2Quality == 0., "large_return_units: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "large_return_units: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "large_return_units: quality restored");
}
// Case 43: deterministic_roughness; model 11 perturbation phase 1.507000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case43()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = 0.001 * sin(12.9898 * I + 78.233 * sin(4.1414 * I));
TS2Returns[I] += 0.00000003 * sin(1.507000 + I * 0.333000);
Snapshot[I] = TS2Returns[I];
}
Original = TS2Evaluate();
InitialQuality = TS2Quality;
InitialStatistic = TS2Statistic;
TS2Expect(Original == Original && abs(Original) <= 1., "deterministic_roughness: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "deterministic_roughness: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "deterministic_roughness: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "deterministic_roughness: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "deterministic_roughness: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "deterministic_roughness: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[29] = 2.;
TS2Expect(TS2Evaluate() == 0., "deterministic_roughness: implausible return rejected");
TS2Expect(TS2Quality == 0., "deterministic_roughness: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "deterministic_roughness: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "deterministic_roughness: quality restored");
}
// Case 44: weeklike_gaps; model 11 perturbation phase 1.507000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case44()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = ifelse(I % 120 < 8, 0., 0.001 * cos(0.33 * I));
TS2Returns[I] += 0.00000003 * sin(1.507000 + I * 0.333000);
Snapshot[I] = TS2Returns[I];
}
Original = TS2Evaluate();
InitialQuality = TS2Quality;
InitialStatistic = TS2Statistic;
TS2Expect(Original == Original && abs(Original) <= 1., "weeklike_gaps: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "weeklike_gaps: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "weeklike_gaps: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "weeklike_gaps: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "weeklike_gaps: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "weeklike_gaps: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[66] = 2.;
TS2Expect(TS2Evaluate() == 0., "weeklike_gaps: implausible return rejected");
TS2Expect(TS2Quality == 0., "weeklike_gaps: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "weeklike_gaps: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "weeklike_gaps: quality restored");
}
// Case 45: quiet_recent_window; model 11 perturbation phase 1.507000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case45()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = ifelse(I < 24, 0., 0.001 * sin(0.27 * I));
TS2Returns[I] += 0.00000003 * sin(1.507000 + I * 0.333000);
Snapshot[I] = TS2Returns[I];
}
Original = TS2Evaluate();
InitialQuality = TS2Quality;
InitialStatistic = TS2Statistic;
TS2Expect(Original == Original && abs(Original) <= 1., "quiet_recent_window: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "quiet_recent_window: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "quiet_recent_window: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "quiet_recent_window: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "quiet_recent_window: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "quiet_recent_window: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[103] = 2.;
TS2Expect(TS2Evaluate() == 0., "quiet_recent_window: implausible return rejected");
TS2Expect(TS2Quality == 0., "quiet_recent_window: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "quiet_recent_window: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "quiet_recent_window: quality restored");
}
// Case 46: quiet_old_window; model 11 perturbation phase 1.507000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case46()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = ifelse(I > 180, 0., 0.001 * sin(0.27 * I));
TS2Returns[I] += 0.00000003 * sin(1.507000 + I * 0.333000);
Snapshot[I] = TS2Returns[I];
}
Original = TS2Evaluate();
InitialQuality = TS2Quality;
InitialStatistic = TS2Statistic;
TS2Expect(Original == Original && abs(Original) <= 1., "quiet_old_window: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "quiet_old_window: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "quiet_old_window: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "quiet_old_window: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "quiet_old_window: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "quiet_old_window: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[140] = 2.;
TS2Expect(TS2Evaluate() == 0., "quiet_old_window: implausible return rejected");
TS2Expect(TS2Quality == 0., "quiet_old_window: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "quiet_old_window: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "quiet_old_window: quality restored");
}
// Case 47: unequal_tail_mass; model 11 perturbation phase 1.507000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case47()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = ifelse(I % 13 == 0, -0.004, 0.00035 + 0.0001 * sin(I));
TS2Returns[I] += 0.00000003 * sin(1.507000 + I * 0.333000);
Snapshot[I] = TS2Returns[I];
}
Original = TS2Evaluate();
InitialQuality = TS2Quality;
InitialStatistic = TS2Statistic;
TS2Expect(Original == Original && abs(Original) <= 1., "unequal_tail_mass: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "unequal_tail_mass: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "unequal_tail_mass: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "unequal_tail_mass: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "unequal_tail_mass: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "unequal_tail_mass: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[177] = 2.;
TS2Expect(TS2Evaluate() == 0., "unequal_tail_mass: implausible return rejected");
TS2Expect(TS2Quality == 0., "unequal_tail_mass: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "unequal_tail_mass: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "unequal_tail_mass: quality restored");
}
// Case 48: bounded_chaotic_phase; model 11 perturbation phase 1.507000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case48()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = 0.001 * sin(I * I * 0.61803398875);
TS2Returns[I] += 0.00000003 * sin(1.507000 + I * 0.333000);
Snapshot[I] = TS2Returns[I];
}
Original = TS2Evaluate();
InitialQuality = TS2Quality;
InitialStatistic = TS2Statistic;
TS2Expect(Original == Original && abs(Original) <= 1., "bounded_chaotic_phase: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "bounded_chaotic_phase: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "bounded_chaotic_phase: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "bounded_chaotic_phase: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "bounded_chaotic_phase: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "bounded_chaotic_phase: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[214] = 2.;
TS2Expect(TS2Evaluate() == 0., "bounded_chaotic_phase: implausible return rejected");
TS2Expect(TS2Quality == 0., "bounded_chaotic_phase: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "bounded_chaotic_phase: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "bounded_chaotic_phase: quality restored");
}
void TS2SelfTest()
{
int I;
TS2Checks = 0;
TS2Failures = 0;
file_write(TS2TestLog, "Synthetic property suite\n", 0);
for (I = 0; I < 256; I++)
TS2Returns[I] = 0.;
TS2Expect(TS2Evaluate() == 0., "flat path has no edge");
TS2Expect(TS2Quality == 0., "flat path clears quality");
TS2KnownResponse();
TS2Case1();
TS2Case2();
TS2Case3();
TS2Case4();
TS2Case5();
TS2Case6();
TS2Case7();
TS2Case8();
TS2Case9();
TS2Case10();
TS2Case11();
TS2Case12();
TS2Case13();
TS2Case14();
TS2Case15();
TS2Case16();
TS2Case17();
TS2Case18();
TS2Case19();
TS2Case20();
TS2Case21();
TS2Case22();
TS2Case23();
TS2Case24();
TS2Case25();
TS2Case26();
TS2Case27();
TS2Case28();
TS2Case29();
TS2Case30();
TS2Case31();
TS2Case32();
TS2Case33();
TS2Case34();
TS2Case35();
TS2Case36();
TS2Case37();
TS2Case38();
TS2Case39();
TS2Case40();
TS2Case41();
TS2Case42();
TS2Case43();
TS2Case44();
TS2Case45();
TS2Case46();
TS2Case47();
TS2Case48();
file_append(TS2TestLog, strf("RESULT: %d checks; %d failures\n", TS2Checks, TS2Failures));
}
// Embedded execution and risk controls; no custom runtime include is required.
function run()
{
int Index;
var Current, Previous, Edge, Sigma, OrderLots, UnitRisk, Budget;
BarPeriod = 60;
LookBack = 260;
StartDate = 20240101;
EndDate = 20241231;
Capital = 10000.;
Hedge = 0;
MaxLong = 1;
MaxShort = 1;
#ifdef TS2_SELFTEST
if (is(INITRUN))
{
TS2SelfTest();
quit("TS2 synthetic tests complete; no historical or live orders");
}
return;
#endif
if (!asset("EUR/USD"))
return;
algo(TS2Algo);
if (is(EXITRUN) || is(LOOKBACK))
return;
for (Index = 0; Index < TS2_N; Index++)
{
Current = priceClose(Index + 1);
Previous = priceClose(Index + 2);
if (!(Current > 0.) || !(Previous > 0.))
{
exitLong();
exitShort();
return;
}
TS2Returns[Index] = log(Current / Previous);
}
Edge = TS2Evaluate();
plot("model edge", Edge, NEW, BLUE);
plot("model quality", TS2Quality, 0, RED);
if (Edge < 0.10 || TS2Quality < 0.15)
exitLong();
if (Edge > -0.10 || TS2Quality < 0.15)
exitShort();
if (abs(Edge) < 0.25 || TS2Quality < 0.30)
return;
if (NumOpenLong + NumOpenShort > 0)
return;
if (PIP <= 0. || PIPCost <= 0. || LotAmount <= 0. || MarginCost <= 0.)
return;
if (Balance <= 0. || Equity < 0.85 * Balance)
return;
Sigma = 0.;
for (Index = 0; Index < 48; Index++)
Sigma += TS2Returns[Index] * TS2Returns[Index] / 48.;
Sigma = sqrt(Sigma) * priceClose(1);
Stop = max(20. * PIP, 3. * Sigma);
TakeProfit = 2. * Stop;
LifeTime = TS2Holding;
UnitRisk = (Stop + abs(Spread)) / PIP * PIPCost;
UnitRisk += abs(Commission) * LotAmount / 10000.;
if (UnitRisk <= 0.)
return;
Budget = 0.0025 * min(Balance, Equity);
OrderLots = min(Budget / UnitRisk, 2000. / LotAmount);
OrderLots = min(OrderLots, max(0., Equity - MarginVal) * 0.5 / MarginCost);
if (OrderLots < 1.)
return;
Lots = floor(OrderLots);
Risk = 0.;
Margin = 0.;
if (Edge > 0.)
enterLong();
else
enterShort();
}
Last edited by TipmyPip; 10 hours ago.
|
|
|
DetrendedScaling
[Re: TipmyPip]
#489737
11 hours ago
11 hours ago
|
Joined: Sep 2017
Posts: 355
TipmyPip
OP
Senior Member
|
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. // 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; 10 hours ago.
|
|
|
DetrendedScaling (cont.)
[Re: TipmyPip]
#489738
11 hours ago
11 hours ago
|
Joined: Sep 2017
Posts: 355
TipmyPip
OP
Senior Member
|
OP
Senior Member
Joined: Sep 2017
Posts: 355
|
// 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: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[206] = 2.;
TS2Expect(TS2Evaluate() == 0., "clustered_down_events: implausible return rejected");
TS2Expect(TS2Quality == 0., "clustered_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, "clustered_down_events: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "clustered_down_events: quality restored");
}
// Case 28: capped_sawtooth; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case28()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = 0.00012 * ((I % 19) - 9);
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., "capped_sawtooth: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "capped_sawtooth: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "capped_sawtooth: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "capped_sawtooth: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "capped_sawtooth: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "capped_sawtooth: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[243] = 2.;
TS2Expect(TS2Evaluate() == 0., "capped_sawtooth: implausible return rejected");
TS2Expect(TS2Quality == 0., "capped_sawtooth: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "capped_sawtooth: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "capped_sawtooth: quality restored");
}
// Case 29: triangular_wave; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case29()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = 0.00015 * (abs((I % 24) - 12) - 6);
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., "triangular_wave: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "triangular_wave: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "triangular_wave: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "triangular_wave: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "triangular_wave: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "triangular_wave: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[24] = 2.;
TS2Expect(TS2Evaluate() == 0., "triangular_wave: implausible return rejected");
TS2Expect(TS2Quality == 0., "triangular_wave: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "triangular_wave: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "triangular_wave: quality restored");
}
// Case 30: convex_drift; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case30()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = 0.0001 + 0.001 * pow(I / 256., 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., "convex_drift: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "convex_drift: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "convex_drift: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "convex_drift: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "convex_drift: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "convex_drift: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[61] = 2.;
TS2Expect(TS2Evaluate() == 0., "convex_drift: implausible return rejected");
TS2Expect(TS2Quality == 0., "convex_drift: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "convex_drift: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "convex_drift: quality restored");
}
// Case 31: concave_drift; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case31()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = 0.0011 - 0.001 * pow(I / 256., 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., "concave_drift: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "concave_drift: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "concave_drift: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "concave_drift: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "concave_drift: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "concave_drift: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[98] = 2.;
TS2Expect(TS2Evaluate() == 0., "concave_drift: implausible return rejected");
TS2Expect(TS2Quality == 0., "concave_drift: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "concave_drift: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "concave_drift: quality restored");
}
// Case 32: sigmoid_transition; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case32()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = 0.001 * (2. / (1. + exp((I - 90.) / 12.)) - 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., "sigmoid_transition: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "sigmoid_transition: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "sigmoid_transition: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "sigmoid_transition: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "sigmoid_transition: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "sigmoid_transition: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[135] = 2.;
TS2Expect(TS2Evaluate() == 0., "sigmoid_transition: implausible return rejected");
TS2Expect(TS2Quality == 0., "sigmoid_transition: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "sigmoid_transition: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "sigmoid_transition: quality restored");
}
// Case 33: damped_oscillation; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case33()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = 0.002 * exp(-0.012 * I) * cos(0.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., "damped_oscillation: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "damped_oscillation: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "damped_oscillation: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "damped_oscillation: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "damped_oscillation: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "damped_oscillation: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[172] = 2.;
TS2Expect(TS2Evaluate() == 0., "damped_oscillation: implausible return rejected");
TS2Expect(TS2Quality == 0., "damped_oscillation: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "damped_oscillation: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "damped_oscillation: quality restored");
}
// Case 34: growing_oscillation; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case34()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = 0.0001 * exp(0.008 * I) * cos(0.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., "growing_oscillation: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "growing_oscillation: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "growing_oscillation: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "growing_oscillation: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "growing_oscillation: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "growing_oscillation: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[209] = 2.;
TS2Expect(TS2Evaluate() == 0., "growing_oscillation: implausible return rejected");
TS2Expect(TS2Quality == 0., "growing_oscillation: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "growing_oscillation: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "growing_oscillation: quality restored");
}
// Case 35: phase_discontinuity; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case35()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = 0.001 * sin(0.3 * I + ifelse(I < 40, 1.5, 0.));
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., "phase_discontinuity: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "phase_discontinuity: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "phase_discontinuity: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "phase_discontinuity: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "phase_discontinuity: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "phase_discontinuity: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[246] = 2.;
TS2Expect(TS2Evaluate() == 0., "phase_discontinuity: implausible return rejected");
TS2Expect(TS2Quality == 0., "phase_discontinuity: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "phase_discontinuity: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "phase_discontinuity: quality restored");
}
// Case 36: frequency_discontinuity; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case36()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = 0.001 * sin(ifelse(I < 80, 0.17, 0.63) * 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., "frequency_discontinuity: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "frequency_discontinuity: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "frequency_discontinuity: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "frequency_discontinuity: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "frequency_discontinuity: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "frequency_discontinuity: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[27] = 2.;
TS2Expect(TS2Evaluate() == 0., "frequency_discontinuity: implausible return rejected");
TS2Expect(TS2Quality == 0., "frequency_discontinuity: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "frequency_discontinuity: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "frequency_discontinuity: quality restored");
}
// Case 37: amplitude_discontinuity; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case37()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = ifelse(I < 80, 0.002, 0.0003) * sin(0.4 * 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., "amplitude_discontinuity: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "amplitude_discontinuity: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "amplitude_discontinuity: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "amplitude_discontinuity: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "amplitude_discontinuity: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "amplitude_discontinuity: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[64] = 2.;
TS2Expect(TS2Evaluate() == 0., "amplitude_discontinuity: implausible return rejected");
TS2Expect(TS2Quality == 0., "amplitude_discontinuity: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "amplitude_discontinuity: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "amplitude_discontinuity: quality restored");
}
// Case 38: smooth_pulse; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case38()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = 0.003 * exp(-pow((I - 32.) / 12., 2.)) - 0.0003;
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., "smooth_pulse: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "smooth_pulse: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "smooth_pulse: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "smooth_pulse: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "smooth_pulse: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "smooth_pulse: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[101] = 2.;
TS2Expect(TS2Evaluate() == 0., "smooth_pulse: implausible return rejected");
TS2Expect(TS2Quality == 0., "smooth_pulse: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "smooth_pulse: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "smooth_pulse: quality restored");
}
// Case 39: double_pulse; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case39()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = 0.002 * exp(-pow((I - 16.) / 6., 2.)) - 0.002 * exp(-pow((I - 60.) / 9., 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., "double_pulse: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "double_pulse: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "double_pulse: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "double_pulse: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "double_pulse: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "double_pulse: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[138] = 2.;
TS2Expect(TS2Evaluate() == 0., "double_pulse: implausible return rejected");
TS2Expect(TS2Quality == 0., "double_pulse: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "double_pulse: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "double_pulse: quality restored");
}
// Case 40: cross_scale_conflict; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case40()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = 0.0008 * cos(0.04 * I) - 0.001 * cos(0.6 * 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., "cross_scale_conflict: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "cross_scale_conflict: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "cross_scale_conflict: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "cross_scale_conflict: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "cross_scale_conflict: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "cross_scale_conflict: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[175] = 2.;
TS2Expect(TS2Evaluate() == 0., "cross_scale_conflict: implausible return rejected");
TS2Expect(TS2Quality == 0., "cross_scale_conflict: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "cross_scale_conflict: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "cross_scale_conflict: quality restored");
}
// Case 41: near_flat_noise; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case41()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = 0.0000002 * sin(0.73 * I) + 0.0000001 * cos(0.29 * 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., "near_flat_noise: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "near_flat_noise: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "near_flat_noise: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "near_flat_noise: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "near_flat_noise: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "near_flat_noise: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[212] = 2.;
TS2Expect(TS2Evaluate() == 0., "near_flat_noise: implausible return rejected");
TS2Expect(TS2Quality == 0., "near_flat_noise: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "near_flat_noise: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "near_flat_noise: quality restored");
}
// Case 42: large_return_units; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case42()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = 0.03 * sin(0.13 * I) + 0.01 * 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., "large_return_units: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "large_return_units: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "large_return_units: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "large_return_units: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "large_return_units: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "large_return_units: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[249] = 2.;
TS2Expect(TS2Evaluate() == 0., "large_return_units: implausible return rejected");
TS2Expect(TS2Quality == 0., "large_return_units: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "large_return_units: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "large_return_units: quality restored");
}
// Case 43: deterministic_roughness; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case43()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = 0.001 * sin(12.9898 * I + 78.233 * sin(4.1414 * 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., "deterministic_roughness: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "deterministic_roughness: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "deterministic_roughness: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "deterministic_roughness: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "deterministic_roughness: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "deterministic_roughness: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[30] = 2.;
TS2Expect(TS2Evaluate() == 0., "deterministic_roughness: implausible return rejected");
TS2Expect(TS2Quality == 0., "deterministic_roughness: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "deterministic_roughness: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "deterministic_roughness: quality restored");
}
// Case 44: weeklike_gaps; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case44()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = ifelse(I % 120 < 8, 0., 0.001 * cos(0.33 * 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., "weeklike_gaps: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "weeklike_gaps: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "weeklike_gaps: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "weeklike_gaps: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "weeklike_gaps: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "weeklike_gaps: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[67] = 2.;
TS2Expect(TS2Evaluate() == 0., "weeklike_gaps: implausible return rejected");
TS2Expect(TS2Quality == 0., "weeklike_gaps: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "weeklike_gaps: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "weeklike_gaps: quality restored");
}
// Case 45: quiet_recent_window; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case45()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = ifelse(I < 24, 0., 0.001 * 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., "quiet_recent_window: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "quiet_recent_window: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "quiet_recent_window: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "quiet_recent_window: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "quiet_recent_window: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "quiet_recent_window: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[104] = 2.;
TS2Expect(TS2Evaluate() == 0., "quiet_recent_window: implausible return rejected");
TS2Expect(TS2Quality == 0., "quiet_recent_window: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "quiet_recent_window: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "quiet_recent_window: quality restored");
}
// Case 46: quiet_old_window; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case46()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = ifelse(I > 180, 0., 0.001 * 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., "quiet_old_window: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "quiet_old_window: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "quiet_old_window: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "quiet_old_window: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "quiet_old_window: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "quiet_old_window: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[141] = 2.;
TS2Expect(TS2Evaluate() == 0., "quiet_old_window: implausible return rejected");
TS2Expect(TS2Quality == 0., "quiet_old_window: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "quiet_old_window: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "quiet_old_window: quality restored");
}
// Case 47: unequal_tail_mass; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case47()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = ifelse(I % 13 == 0, -0.004, 0.00035 + 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., "unequal_tail_mass: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "unequal_tail_mass: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "unequal_tail_mass: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "unequal_tail_mass: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "unequal_tail_mass: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "unequal_tail_mass: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[178] = 2.;
TS2Expect(TS2Evaluate() == 0., "unequal_tail_mass: implausible return rejected");
TS2Expect(TS2Quality == 0., "unequal_tail_mass: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "unequal_tail_mass: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "unequal_tail_mass: quality restored");
}
// Case 48: bounded_chaotic_phase; model 12 perturbation phase 1.644000.
// Covers numerical stability and directional symmetry on this path family.
void TS2Case48()
{
var Snapshot[256], Original, Repeated, Reflected, Restored;
var InitialQuality, InitialStatistic;
int I;
for (I = 0; I < 256; I++)
{
TS2Returns[I] = 0.001 * sin(I * I * 0.61803398875);
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., "bounded_chaotic_phase: finite bounded edge");
TS2Expect(InitialQuality >= 0. && InitialQuality <= 1., "bounded_chaotic_phase: quality contract");
TS2Expect(InitialStatistic == InitialStatistic && abs(InitialStatistic) < 1.e12, "bounded_chaotic_phase: finite diagnostic");
Repeated = TS2Evaluate();
TS2Expect(abs(Repeated - Original) < 1.e-9, "bounded_chaotic_phase: deterministic evaluation");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "bounded_chaotic_phase: deterministic quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = -Snapshot[I];
Reflected = TS2Evaluate();
TS2Expect(abs(Reflected + Original) < 1.e-7, "bounded_chaotic_phase: directional reflection");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
TS2Returns[215] = 2.;
TS2Expect(TS2Evaluate() == 0., "bounded_chaotic_phase: implausible return rejected");
TS2Expect(TS2Quality == 0., "bounded_chaotic_phase: rejected sample clears quality");
for (I = 0; I < 256; I++)
TS2Returns[I] = Snapshot[I];
Restored = TS2Evaluate();
TS2Expect(abs(Restored - Original) < 1.e-9, "bounded_chaotic_phase: restored input has no stale state");
TS2Expect(abs(TS2Quality - InitialQuality) < 1.e-9, "bounded_chaotic_phase: quality restored");
}
void TS2SelfTest()
{
int I;
TS2Checks = 0;
TS2Failures = 0;
file_write(TS2TestLog, "Synthetic property suite\n", 0);
for (I = 0; I < 256; I++)
TS2Returns[I] = 0.;
TS2Expect(TS2Evaluate() == 0., "flat path has no edge");
TS2Expect(TS2Quality == 0., "flat path clears quality");
TS2KnownResponse();
TS2Case1();
TS2Case2();
TS2Case3();
TS2Case4();
TS2Case5();
TS2Case6();
TS2Case7();
TS2Case8();
TS2Case9();
TS2Case10();
TS2Case11();
TS2Case12();
TS2Case13();
TS2Case14();
TS2Case15();
TS2Case16();
TS2Case17();
TS2Case18();
TS2Case19();
TS2Case20();
TS2Case21();
TS2Case22();
TS2Case23();
TS2Case24();
TS2Case25();
TS2Case26();
TS2Case27();
TS2Case28();
TS2Case29();
TS2Case30();
TS2Case31();
TS2Case32();
TS2Case33();
TS2Case34();
TS2Case35();
TS2Case36();
TS2Case37();
TS2Case38();
TS2Case39();
TS2Case40();
TS2Case41();
TS2Case42();
TS2Case43();
TS2Case44();
TS2Case45();
TS2Case46();
TS2Case47();
TS2Case48();
file_append(TS2TestLog, strf("RESULT: %d checks; %d failures\n", TS2Checks, TS2Failures));
}
// Embedded execution and risk controls; no custom runtime include is required.
function run()
{
int Index;
var Current, Previous, Edge, Sigma, OrderLots, UnitRisk, Budget;
BarPeriod = 60;
LookBack = 260;
StartDate = 20240101;
EndDate = 20241231;
Capital = 10000.;
Hedge = 0;
MaxLong = 1;
MaxShort = 1;
#ifdef TS2_SELFTEST
if (is(INITRUN))
{
TS2SelfTest();
quit("TS2 synthetic tests complete; no historical or live orders");
}
return;
#endif
if (!asset("EUR/USD"))
return;
algo(TS2Algo);
if (is(EXITRUN) || is(LOOKBACK))
return;
for (Index = 0; Index < TS2_N; Index++)
{
Current = priceClose(Index + 1);
Previous = priceClose(Index + 2);
if (!(Current > 0.) || !(Previous > 0.))
{
exitLong();
exitShort();
return;
}
TS2Returns[Index] = log(Current / Previous);
}
Edge = TS2Evaluate();
plot("model edge", Edge, NEW, BLUE);
plot("model quality", TS2Quality, 0, RED);
if (Edge < 0.10 || TS2Quality < 0.15)
exitLong();
if (Edge > -0.10 || TS2Quality < 0.15)
exitShort();
if (abs(Edge) < 0.25 || TS2Quality < 0.30)
return;
if (NumOpenLong + NumOpenShort > 0)
return;
if (PIP <= 0. || PIPCost <= 0. || LotAmount <= 0. || MarginCost <= 0.)
return;
if (Balance <= 0. || Equity < 0.85 * Balance)
return;
Sigma = 0.;
for (Index = 0; Index < 48; Index++)
Sigma += TS2Returns[Index] * TS2Returns[Index] / 48.;
Sigma = sqrt(Sigma) * priceClose(1);
Stop = max(20. * PIP, 3. * Sigma);
TakeProfit = 2. * Stop;
LifeTime = TS2Holding;
UnitRisk = (Stop + abs(Spread)) / PIP * PIPCost;
UnitRisk += abs(Commission) * LotAmount / 10000.;
if (UnitRisk <= 0.)
return;
Budget = 0.0025 * min(Balance, Equity);
OrderLots = min(Budget / UnitRisk, 2000. / LotAmount);
OrderLots = min(OrderLots, max(0., Equity - MarginVal) * 0.5 / MarginCost);
if (OrderLots < 1.)
return;
Lots = floor(OrderLots);
Risk = 0.;
Margin = 0.;
if (Edge > 0.)
enterLong();
else
enterShort();
}
Last edited by TipmyPip; 10 hours ago.
|
|
|
|
