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 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 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); }
/// <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 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 TestTemporalDatabase() { 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(); DateTime start = new DateTime(1997, 1, 1, 0, 0, 0, 0); analysis.sampleTime = new TimeSpan(0, 0, 1); analysis.LoadSampledData(logistic, start, new TimeSpan(0, 0, 1)); Assert.AreEqual(start, analysis.earliest); Assert.AreEqual(start + new TimeSpan(9990000000), analysis.latest); Assert.AreEqual(1000, analysis.Count); Assert.AreEqual(logistic[0], analysis[0]); Assert.AreEqual(logistic[999], analysis[999]); Assert.AreEqual(logistic[599], analysis[599]); Assert.AreEqual(logistic[768], analysis[768]); //remove before start analysis.RemoveBefore(new DateTime(1997, 1, 1, 0, 0, 0, 0)); Assert.AreEqual(start, analysis.earliest); Assert.AreEqual(start + new TimeSpan(9990000000), analysis.latest); //remove before fixed point DateTime newStart = new DateTime(1997, 1, 1, 0, 12, 0, 0); analysis.RemoveBefore(newStart); Assert.AreEqual(newStart, analysis.earliest); Assert.AreEqual(start + new TimeSpan(9990000000), analysis.latest); newStart = new DateTime(1997, 1, 1, 1, 12, 0, 0); analysis.RemoveBefore(newStart); Assert.AreEqual(DateTime.MinValue, analysis.earliest); Assert.AreEqual(DateTime.MaxValue, analysis.latest); }
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 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 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 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 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 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 TestGetNextValidTradingTimes() { ChaosAnalysis analysis = new ChaosAnalysis(); TimeSpan sampleTime = new TimeSpan(1, 0, 0); TradingTimes tr = new TradingTimes(); tr.tradingDays = new bool[] { false, true, true, true, true, true, false }; double[] linear = new double[1000]; linear[0] = 0.1; for (int n = 1; n < 1000; n++) { linear[n] = linear[n - 1] + 1.0; } DateTime start = new DateTime(2000, 1, 1); analysis.LoadSampledData(linear, start, sampleTime); analysis.SortEvents(); DateTime[] offsets = analysis.GetNextValidTradingTimes(9); Assert.AreEqual(9, offsets.Length); }
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); }
public void TestTemporalDatabaseWithTaggedData() { double[] logistic = new double[1000]; DateTime[] times = new DateTime[1000]; DateTime start = new DateTime(1997, 1, 1, 0, 0, 0, 0); logistic[0] = 0.1; times[0] = start; TimeSpan offset = new TimeSpan(0, 1, 0); DateTime iterator = start; for (int n = 1; n < 1000; n++) { logistic[n] = 4.0 * logistic[n - 1] * (1.0 - logistic[n - 1]); iterator += offset; times[n] = iterator; } ChaosAnalysis analysis = new ChaosAnalysis(); analysis.LoadTaggedData(logistic, times); analysis.sampleTime = offset; analysis.interpolation = true; Assert.AreEqual(start, analysis.earliest); Assert.AreEqual(iterator, analysis.latest); Assert.AreEqual(1000, analysis.Count); Assert.AreEqual(logistic[0], analysis[0]); Assert.AreEqual(logistic[999], analysis[999]); Assert.AreEqual(logistic[599], analysis[599]); Assert.AreEqual(logistic[768], analysis[768]); //test interpolation TimeSpan testOfset = new TimeSpan((long)((double)offset.Ticks * 599.5)); Assert.AreEqual((logistic[599] + logistic[600]) / 2.0, analysis[start + testOfset]); testOfset = new TimeSpan((long)((double)offset.Ticks * 200.5)); Assert.AreEqual((logistic[200] + logistic[201]) / 2.0, analysis[start + testOfset]); // Assert.ReferenceEquals(double.NaN,analysis[DateTime.MinValue]); Assert.AreEqual(logistic[999], analysis[DateTime.MaxValue]); //remove before start analysis.RemoveBefore(new DateTime(1997, 1, 1, 0, 0, 0, 0)); Assert.AreEqual(start, analysis.earliest); Assert.AreEqual(iterator, analysis.latest); //remove before fixed point DateTime newStart = new DateTime(1997, 1, 1, 0, 12, 0, 0); analysis.RemoveBefore(newStart); Assert.AreEqual(newStart, analysis.earliest); Assert.AreEqual(iterator, analysis.latest); newStart = new DateTime(1997, 1, 1, 17, 0, 0, 0); analysis.RemoveBefore(newStart); Assert.AreEqual(DateTime.MinValue, analysis.earliest); Assert.AreEqual(DateTime.MaxValue, analysis.latest); //now test unequally spaced events double[] data = new double[500]; times = new DateTime[500]; iterator = start; for (int n = 0; n < 500; n++) { data[n] = (double)n; times[n] = iterator; TimeSpan testOffset = new TimeSpan((long)((double)offset.Ticks * ((double)n / 100 + 1))); iterator += testOffset; } analysis = new ChaosAnalysis(); analysis.LoadTaggedData(data, times); analysis.sampleTime = offset; analysis.interpolation = true; Assert.AreEqual(start, analysis.earliest); Assert.AreEqual(1742, analysis.Count);//This is not the count of events, but the count of the number of samples in the database, based on the sample time. // Assert.AreEqual(data[0],analysis[times[0]]); Assert.AreEqual(data[199], analysis[times[199]]); Assert.AreEqual(data[299], analysis[times[299]]); Assert.AreEqual(data[468], analysis[times[468]]); //test interpolation DateTime testtime = new DateTime((times[199].Ticks + times[200].Ticks) / 2);//halfway between two samples Assert.AreEqual((data[199] + data[200]) / 2.0, analysis[testtime]); testtime = new DateTime((times[303].Ticks + times[304].Ticks) / 2);//halfway between two samples Assert.AreEqual((data[303] + data[304]) / 2.0, analysis[testtime], 0.000001); }