/// <summary>
/// Test with a linear series differenced
/// </summary>
/// <remarks> This series continually extends its range.
/// D1fferencing produces more accurate results.
/// This is also an interesting test because all the differences are the same.
/// It thus represents an extreme set of cirumstances that must be handled.</remarks>
public void TestPredictLinearDifferenced()
{
double[] linear = new double[1000];
linear[0] = 0.1;
for (int n = 1; n < 1000; n++)
{
linear[n] = linear[n - 1] + 1.0;
}
ChaosAnalysis analysis = new ChaosAnalysis();
analysis.differencing = true;
TimeSpan sampleTime = new TimeSpan(0, 0, 1);
analysis.LoadSampledData(linear, DateTime.Now, sampleTime);
Assert.IsTrue(analysis.CalculateMeasures(true, false, true));
linear[0] = linear[linear.Length - 1];
double error = 0.0;
for (int n = 1; n < 1000; n++)
{
linear[n] = linear[n - 1] + 1.0;
double[] result = analysis.Predict(1, analysis.latest);
analysis.AddDataPointRelative(linear[n], sampleTime);
//we're predicting the difference, so relative to last
double diff = linear[n] - (result[0] + linear[n - 1]);
error += diff * diff;
}
error = Math.Sqrt(error / 1000);
Assert.AreEqual(0.0, error, 0.01);
}
public void TestPredictLogisticMultiple()
{
double[] logistic = new double[1000];
logistic[0] = 0.1;
for (int n = 1; n < 1000; n++)
{
logistic[n] = 4.0 * logistic[n - 1] * (1.0 - logistic[n - 1]);
}
ChaosAnalysis analysis = new ChaosAnalysis();
TimeSpan sampleTime = new TimeSpan(0, 0, 1);
analysis.LoadSampledData(logistic, DateTime.Now, sampleTime);
Assert.IsTrue(analysis.CalculateMeasures(true, false, true));
logistic[0] = logistic[logistic.Length - 1];
double error = 0.0;
double[] result = analysis.Predict(10, analysis.latest);
double[] errors = new double[10];
for (int n = 1; n < 11; n++)
{
logistic[n] = 4.0 * logistic[n - 1] * (1.0 - logistic[n - 1]);
double diff = logistic[n] - result[n - 1];
error += diff * diff;
errors[n - 1] = Math.Sqrt(diff * diff);
}
error = Math.Sqrt(error / 10);
Assert.AreEqual(0.00631, errors[0], 0.001);
Assert.AreEqual(0.01522, errors[1], 0.001);
Assert.AreEqual(0.01838, errors[2], 0.001);
Assert.AreEqual(0.05689, errors[3], 0.001);
Assert.AreEqual(0.08324, errors[4], 0.001);
Assert.AreEqual(0.29876, error, 0.001);
}
public void TestTent()
{
Trace.WriteLine("Tent");
double[] tent = new double[samples];
tent[0] = 0.1;
for (int n = 1; n < samples; n++)
{
if (tent[n - 1] < 0.5)
{
tent[n] = 1.9 * tent[n - 1];
}
else
{
tent[n] = 1.9 * (1 - tent[n - 1]);
}
}
ChaosAnalysis analysis = new ChaosAnalysis();
analysis.LoadSampledData(tent, DateTime.Now, new TimeSpan(0, 0, 1));
analysis.sampleTime = new TimeSpan(0, 0, 1);
Assert.IsTrue(analysis.CalculateMeasures(true, false, true));
Assert.AreEqual(2, analysis.optimalEmbeddingDimension);
Assert.AreEqual(1, analysis.optimalEmbeddingSeparation);
Assert.AreEqual(0.4570, analysis.Hurst, 0.001);
Assert.AreEqual(0.9018, analysis.Lyapunov, 0.001);
}
public void TestLorentz()
{
Trace.WriteLine("Lorenz");
double h = 0.01;
double a = 10.0;
double b = 28.0;
double c = 8.0 / 3.0;
XYZ p = new XYZ(0, 0, 0);;
XYZ plast = new XYZ(0.1, 0, 0);
double[] xDimLorentz = new double[10000];
int index = 0;
for (int i = 0; i < 10100; i++)
{
p.x = plast.x + h * a * (plast.y - plast.x);
p.y = plast.y + h * (plast.x * (b - plast.z) - plast.y);
p.z = plast.z + h * (plast.x * plast.y - c * plast.z);
if (i > 100)
{
xDimLorentz[index++] = p.x;
}
plast = p;
}
ChaosAnalysis analysis = new ChaosAnalysis();
analysis.LoadSampledData(xDimLorentz, DateTime.Now, new TimeSpan(0, 0, 1));
analysis.sampleTime = new TimeSpan(0, 0, 1);
Assert.IsTrue(analysis.CalculateMeasures(true, false, true));
Assert.AreEqual(2, analysis.optimalEmbeddingDimension);
Assert.AreEqual(4, analysis.optimalEmbeddingSeparation);
Assert.AreEqual(0.90129, analysis.Hurst, 0.001);
Assert.AreEqual(0.0789, analysis.Lyapunov, 0.001);
}
public void TestPredictLogisticWithPredictNext()
{
double[] logistic = new double[1000];
logistic[0] = 0.1;
for (int n = 1; n < 1000; n++)
{
logistic[n] = 4.0 * logistic[n - 1] * (1.0 - logistic[n - 1]);
}
ChaosAnalysis analysis = new ChaosAnalysis();
TimeSpan sampleTime = new TimeSpan(0, 0, 1);
analysis.LoadSampledData(logistic, DateTime.Now, sampleTime);
Assert.IsTrue(analysis.CalculateMeasures(true, false, true));
logistic[0] = logistic[logistic.Length - 1];
double error = 0.0;
for (int n = 1; n < 1000; n++)
{
logistic[n] = 4.0 * logistic[n - 1] * (1.0 - logistic[n - 1]);
double[] result;
if (n == 1)
{
result = analysis.Predict(1, analysis.latest);
}
else
{
result = analysis.PredictNext(1, analysis.latest);
}
analysis.AddDataPointRelative(logistic[n], sampleTime);
double diff = logistic[n] - result[0];
error += diff * diff;
}
error = Math.Sqrt(error / 1000);
Assert.AreEqual(0.00403954, error, 0.001);
}
public void TestMackayGlass()
{
Trace.WriteLine("MackayGlass");
double[] mackayGlass = new double[10100];
for (int n = 0; n < 18; n++)
{
mackayGlass[n] = 0.7;
}
for (int n = 19; n < 10100; n++)
{
mackayGlass[n] = 0.9 * mackayGlass[n - 1] + 0.2 * (mackayGlass[n - 18] / (1.0 + Math.Pow(mackayGlass[n - 18], 10)));
}
double[] mackayGlass2 = new double[10000];
for (int n = 100; n < 10100; n++)
{
mackayGlass2[n - 100] = mackayGlass[n];
}
ChaosAnalysis analysis = new ChaosAnalysis();
analysis.LoadSampledData(mackayGlass2, DateTime.Now, new TimeSpan(0, 0, 1));
analysis.sampleTime = new TimeSpan(0, 0, 1);
Assert.IsTrue(analysis.CalculateMeasures(true, false, true));
Assert.AreEqual(2, analysis.optimalEmbeddingDimension);
Assert.AreEqual(1, analysis.optimalEmbeddingSeparation);
Assert.AreEqual(0.65412, analysis.Hurst, 0.005);
Assert.AreEqual(1.07493, analysis.Lyapunov, 0.01);
}
public void TestRossler()
{
Trace.WriteLine("Rossler");
double h = 0.05; /* or smaller */
double a = 0.2;
double b = 0.2;
double c = 5.7;
XYZ p = new XYZ(0, 0, 0);;
XYZ plast = new XYZ(0.1, 0, 0);
double[] xDimRossler = new double[10000];
int index = 0;
for (int i = 0; i < 10100; i++)
{
p.x = plast.x + h * (-plast.y - plast.z);
p.y = plast.y + h * (plast.x + a * plast.y);
p.z = plast.z + h * (b + plast.z * (plast.x - c));
if (i > 100)
{
xDimRossler[index++] = p.x;
}
plast = p;
}
ChaosAnalysis analysis = new ChaosAnalysis();
analysis.LoadSampledData(xDimRossler, DateTime.Now, new TimeSpan(0, 0, 1));
analysis.sampleTime = new TimeSpan(0, 0, 1);
Assert.IsTrue(analysis.CalculateMeasures(true, false, true));
Assert.AreEqual(2, analysis.optimalEmbeddingDimension);
Assert.AreEqual(1, analysis.optimalEmbeddingSeparation);
Assert.AreEqual(0.82081, analysis.Hurst, 0.001);
Assert.AreEqual(0.838, analysis.Lyapunov, 0.001);
}
public void TestGetSampledPoint()
{
double[] linear = new double[1000];
linear[0] = 0.1;
for (int n = 1; n < 1000; n++)
{
linear[n] = linear[n - 1] + 1.0;
}
ChaosAnalysis analysis = new ChaosAnalysis();
TimeSpan sampleTime = new TimeSpan(1, 0, 0);
DateTime start = new DateTime(2000, 1, 1);
analysis.LoadSampledData(linear, start, sampleTime);
analysis.CalculateMeasures(true, false, true);
DateTime offset1 = start + new TimeSpan(sampleTime.Ticks * 3 + sampleTime.Ticks / 2);
Assert.AreEqual(3.1, analysis.GetSampledPoint(offset1));
analysis.interpolation = true;
Assert.AreEqual(3.6, analysis.GetSampledPoint(offset1), 0.01);
DateTime offset2 = start - new TimeSpan(sampleTime.Ticks * 3 + sampleTime.Ticks / 2);
Assert.AreEqual(0.0, analysis.GetSampledPoint(offset2), 0.01);
DateTime offset3 = analysis.latest + new TimeSpan(sampleTime.Ticks * 3 + sampleTime.Ticks / 2);
Assert.AreEqual(999.1, analysis.GetSampledPoint(offset3), 0.01);
}
public void TestPartCrazy()
{
Trace.WriteLine("PartCrazy");
double[] partCrazy = new double[samples];
for (int n = 0; n < samples; n++)
{
partCrazy[n] = (n % 3) / 2;
}
ChaosAnalysis analysis = new ChaosAnalysis();
analysis.LoadSampledData(partCrazy, DateTime.Now, new TimeSpan(0, 0, 1));
analysis.sampleTime = new TimeSpan(0, 0, 1);
Assert.IsTrue(analysis.CalculateMeasures(true, false, true));
Assert.AreEqual(2, analysis.optimalEmbeddingDimension);
Assert.AreEqual(1, analysis.optimalEmbeddingSeparation);
Assert.AreEqual(0.0217, analysis.Hurst, 0.001);
Assert.AreEqual(0.5, analysis.Lyapunov, 0.001);
}
public void TestSine()
{
Trace.WriteLine("Sine");
double[] sine = new double[samples];
for (int n = 0; n < samples; n++)
{
sine[n] = Math.Sin(n * Math.PI / 180);
}
ChaosAnalysis analysis = new ChaosAnalysis();
analysis.LoadSampledData(sine, DateTime.Now, new TimeSpan(0, 0, 1));
analysis.sampleTime = new TimeSpan(0, 0, 1);
Assert.IsTrue(analysis.CalculateMeasures(true, false, true));
Assert.AreEqual(2, analysis.optimalEmbeddingDimension);
Assert.AreEqual(2, analysis.optimalEmbeddingSeparation);
Assert.AreEqual(0.997, analysis.Hurst, 0.001);
Assert.AreEqual(0.384, analysis.Lyapunov, 0.001);
}
public void TestLogistic()
{
Trace.WriteLine("logistic");
double[] logistic = new double[10000];
logistic[0] = 0.1;
for (int n = 1; n < 10000; n++)
{
logistic[n] = 4.0 * logistic[n - 1] * (1.0 - logistic[n - 1]);
}
ChaosAnalysis analysis = new ChaosAnalysis();
analysis.LoadSampledData(logistic, DateTime.Now, new TimeSpan(0, 0, 1));
analysis.sampleTime = new TimeSpan(0, 0, 1);
Assert.IsTrue(analysis.CalculateMeasures(true, false, true));
Assert.AreEqual(2, analysis.optimalEmbeddingDimension);
Assert.AreEqual(1, analysis.optimalEmbeddingSeparation);
Assert.AreEqual(0.55934, analysis.Hurst, 0.001);
Assert.AreEqual(0.98410, analysis.Lyapunov, 0.001);
}
public void TestLinear()
{
Trace.WriteLine("Linear");
double[] linear = new double[samples];
linear[0] = 0.1;
for (int n = 1; n < samples; n++)
{
linear[n] = linear[n - 1] + 1.0;
}
ChaosAnalysis analysis = new ChaosAnalysis();
analysis.LoadSampledData(linear, DateTime.Now, new TimeSpan(0, 0, 1));
analysis.sampleTime = new TimeSpan(0, 0, 1);
Assert.IsTrue(analysis.CalculateMeasures(true, false, true));
Assert.AreEqual(2, analysis.optimalEmbeddingDimension);
Assert.AreEqual(1, analysis.optimalEmbeddingSeparation);
Assert.AreEqual(1.000, analysis.Hurst, 0.001);
Assert.AreEqual(0.000, analysis.Lyapunov, 0.001);
}
public void TestRandom()
{
Trace.WriteLine("Random");
double[] random = new double[samples];
Random rand = new Random(1234);
for (int n = 0; n < samples; n++)
{
random[n] = rand.NextDouble();
}
ChaosAnalysis analysis = new ChaosAnalysis();
analysis.LoadSampledData(random, DateTime.Now, new TimeSpan(0, 0, 1));
analysis.sampleTime = new TimeSpan(0, 0, 1);
Assert.IsFalse(analysis.CalculateMeasures(true, false, true));
Assert.AreEqual(2, analysis.optimalEmbeddingDimension);
Assert.AreEqual(2, analysis.optimalEmbeddingSeparation);
Assert.AreEqual(0.6283, analysis.Hurst, 0.001);
Assert.AreEqual(2.94264, analysis.Lyapunov, 0.01);
}
public void TestCrazy()
{
Trace.WriteLine("Crazy");
double[] linear = new double[samples];
linear[0] = 0.1;
for (int n = 1; n < samples; n++)
{
if (n % 2 == 0)
{
linear[n] = 0.1;
}
else
{
linear[n] = 0.5;
}
}
ChaosAnalysis analysis = new ChaosAnalysis();
analysis.LoadSampledData(linear, DateTime.Now, new TimeSpan(0, 0, 1));
analysis.sampleTime = new TimeSpan(0, 0, 1);
Assert.IsTrue(analysis.CalculateMeasures(true, false, true));
Assert.AreEqual(0.0000, analysis.Hurst, 0.001);
Assert.AreEqual(0.000, analysis.Lyapunov, 0.001);
}
