def test_flatTrendTest(self):
""" generated source for method flatTrendTest """
seed = 1234567
data = self.testDataGenerator.createNoisySeasonalData(144, 12, 1.0, 0.0, 0.1, seed)
builder = SeasonalTrendLoess.Builder().setFlatTrend().setPeriodLength(12).setSeasonalWidth(1000000).setRobust()
smoother = builder.buildSmoother(data)
stl = smoother.decompose()
trend = stl.getTrend()
for i in range(1,len(trend)):
self.assertAlmostEqual(0.0, trend[i] - trend[i - 1], delta=1.0e-13)
def test_flatTrendBuilderCanBeReused(self):
""" generated source for method flatTrendBuilderCanBeReused """
data = TestSimulatedWeeklyMetric.getFourWeekValues()
periodicity = 1008
builder = SeasonalTrendLoess.Builder()
builder.setPeriodLength(periodicity).setRobust().setFlatTrend().setSeasonalWidth(101)
stlSmoother = builder.buildSmoother(data)
stl = stlSmoother.decompose()
self.assertIsNotNone(stl)
builder.setRobustnessIterations(17)
stlSmoother = builder.buildSmoother(data)
stl = stlSmoother.decompose()
self.assertIsNotNone(stl)
def test___str__Test(self):
""" generated source for method toStringTest """
data = self.testDataGenerator.createNoisySeasonalDataWithTimeSeed(144, 12, 10.0, 1.0, 2.0)
builder = SeasonalTrendLoess.Builder().setPeriodLength(12).setSeasonalWidth(7).setNonRobust()
stl = builder.buildSmoother(data)
self.assertAlmostEqual("SeasonalTrendLoess: [\n" +
"inner iterations = 2\n" +
"outer iterations = 0\n" +
"periodicity = 12\n" +
"seasonality settings = [width = 7, degree = 1, jump = 1]\n" +
"trend settings = [width = 23, degree = 1, jump = 3]\n" +
"lowpass settings = [width = 13, degree = 1, jump = 2]\n]",
stl.__str__())
def test_linearTrendTest(self):
""" generated source for method linearTrendTest """
seed = 1234567
data = self.testDataGenerator.createNoisySeasonalData(144, 12, 1.0, 0.2, 0.1, seed)
builder = SeasonalTrendLoess.Builder().setLinearTrend().setPeriodLength(12).setSeasonalWidth(1000000).setRobust()
smoother = builder.buildSmoother(data)
stl = smoother.decompose()
trend = stl.getTrend()
dt = trend[1] - trend[0]
for i in range(1,len(trend)):
self.assertAlmostEqual(dt, trend[i] - trend[i - 1], delta=1.0e-14)
dx = 2 * math.pi / 12
self.assertAlmostEqual(dt, 0.2 * dx, delta=1.0e-4)
def test_pureSineTest(self):
""" generated source for method pureSineTest """
seed = 1234567
# System.nanoTime() // change this to do random stress test
data = self.testDataGenerator.createNoisySeasonalData(144, 12, 1.0, 0.0, 0.0, seed)
builder = SeasonalTrendLoess.Builder().setPeriodLength(12).setSeasonalWidth(7).setNonRobust()
smoother = builder.buildSmoother(data)
stl = smoother.decompose()
trend = stl.getTrend()
seasonal = stl.getSeasonal()
residuals = stl.getResidual()
for i in range(len(data)):
self.assertAlmostEqual(data[i], seasonal[i], delta=1.0e-14)
self.assertAlmostEqual(0.0, trend[i], delta=1.0e-14)
self.assertAlmostEqual(0.0, residuals[i], delta=1.0e-14)
def test_squareWaveTest(self):
""" generated source for method squareWaveTest """
data = self.testDataGenerator.createSquareWaveData()
builder = SeasonalTrendLoess.Builder().setPeriodLength(288).setSeasonalWidth(13).setNonRobust()
smoother = builder.buildSmoother(data)
stl = smoother.decompose()
trend = stl.getTrend()
seasonal = stl.getSeasonal()
residuals = stl.getResidual()
weights = stl.getWeights()
for i in range(len(data)):
self.assertAlmostEqual(42.5, trend[i], delta=1.0e-12)
self.assertAlmostEqual(data[i], seasonal[i] + stl.getTrend()[i], delta=1.0e-12)
self.assertAlmostEqual(0.0, residuals[i], delta=1.0e-12)
self.assertAlmostEqual(1.0, weights[i], delta=1.0e-13)
def test_pureNoiseTest(self):
""" generated source for method pureNoiseTest """
data = self.testDataGenerator.createNoisySeasonalDataWithTimeSeed(144, 12, 0.0, 0.0, 1.0)
builder = SeasonalTrendLoess.Builder().setPeriodLength(12).setSeasonalWidth(7).setRobust()
smoother = builder.buildSmoother(data)
stl = smoother.decompose()
trend = stl.getTrend()
seasonal = stl.getSeasonal()
residuals = stl.getResidual()
rsum = 0.0
r2sum = 0.0
dsum = 0.0
d2sum = 0.0
tsum = 0.0
t2sum = 0.0
ssum = 0.0
s2sum = 0.0
for i in range(len(data)):
r = residuals[i]
rsum += r
r2sum += r * r
d = data[i]
dsum += d
d2sum += d * d
t = trend[i]
tsum += t
t2sum += t * t
s = seasonal[i]
ssum += s
s2sum += s * s
trendMean = tsum / len(data)
trendVar = (t2sum - trendMean * trendMean) / (len(data) - 1)
resMean = rsum / len(data)
resVar = (r2sum - resMean * resMean) / (len(data) - 1)
dataMean = dsum / len(data)
dataVar = (d2sum - dataMean * dataMean) / (len(data) - 1)
seasonalMean = ssum / len(data)
seasonalVar = (s2sum - seasonalMean * seasonalMean) / (len(data) - 1)
stlMean = seasonalMean + trendMean + resMean
self.assertAlmostEqual(dataMean, stlMean, delta=1.0e-8)
stlVar = seasonalVar + trendVar + resVar
print(" \t\tmean\tvariance")
print("data \t{}\t{}".format(dataMean, dataVar))
print("seasonal \t{}\t{}".format(seasonalMean, seasonalVar))
print("trend \t{}\t{}".format(trendMean, trendVar))
print("residual \t{}\t{}".format(resMean, resVar))
print("stl sum \t{}\t{}".format(stlMean, stlVar))
def test_pureTrendTest(self):
""" generated source for method pureTrendTest """
seed = 1234567
data = self.testDataGenerator.createNoisySeasonalData(144, 12, 0.0, 1.0, 0.0, seed)
builder = SeasonalTrendLoess.Builder().setPeriodLength(12).setSeasonalWidth(7).setNonRobust()
smoother = builder.buildSmoother(data)
stl = smoother.decompose()
trend = stl.getTrend()
seasonal = stl.getSeasonal()
residuals = stl.getResidual()
weights = stl.getWeights()
for i in range(len(data)):
self.assertAlmostEqual(data[i], trend[i], delta=1.0e-12)
self.assertAlmostEqual(0.0, seasonal[i], delta=1.0e-12)
self.assertAlmostEqual(0.0, residuals[i], delta=1.0e-12)
self.assertAlmostEqual(1.0, weights[i], delta=1.0e-13)
def test_stlDataFactory(self):
""" generated source for method stlDataFactory """
data = self.testDataGenerator.createNoisySeasonalDataWithTimeSeed(144, 12, 10.0, 1.0, 2.0)
builder = SeasonalTrendLoess.Builder().setPeriodLength(12).setSeasonalWidth(7).setNonRobust()
smoother = builder.buildSmoother(data)
stl = smoother.decompose()
residuals = stl.getResidual()
rsum = 0.0
r2sum = 0.0
for i in range(len(data)):
r = residuals[i]
rsum += r
r2sum += r * r
mean = rsum / len(data)
variance = (r2sum - rsum * rsum) / (len(data) - 1)
print("Residual has mean {} and variance {}".format(mean, variance))
def test_robustRegressionTest(self):
""" generated source for method robustRegressionTest """
data = np.zeros(144)
for i in range(len(data)):
data[i] = self.fRobustNoisySinusoidResults[i,0]
builder = SeasonalTrendLoess.Builder().setPeriodLength(12).setSeasonalWidth(7)
builder.setInnerIterations(1).setRobustnessIterations(1)
smoother = builder.buildSmoother(data)
stl = smoother.decompose()
epsilon = 2.0e-07
trend = stl.getTrend()
seasonal = stl.getSeasonal()
residuals = stl.getResidual()
for i in range(len(data)):
self.assertAlmostEqual(self.fRobustNoisySinusoidResults[i][1], trend[i], msg="seasonal[{}]".format(i), delta=epsilon)
self.assertAlmostEqual(self.fRobustNoisySinusoidResults[i][2], seasonal[i], msg="trend[{}]".format(i), delta=epsilon)
self.assertAlmostEqual(self.fRobustNoisySinusoidResults[i][3], residuals[i], msg="residuals[{}]".format(i), delta=epsilon)
def test_forcedPeriodicityTest(self):
""" generated source for method forcedPeriodicityTest """
data = np.zeros(144)
for i in range(len(data)):
data[i] = self.fNonRobustNoisySinusoidResults[i,0]
builder = SeasonalTrendLoess.Builder().setPeriodLength(12)
builder.setSeasonalWidth(100000001).setSeasonalDegree(0).setSeasonalJump(100000001)
builder.setTrendWidth(23)
builder.setLowpassWidth(13)
builder.setInnerIterations(2).setRobustnessIterations(0)
smoother = builder.buildSmoother(data)
stl = smoother.decompose()
epsilon = 1.0e-10
seasonal = stl.getSeasonal()
for i in range(12):
for p in range(12):
self.assertAlmostEqual(seasonal[i], seasonal[i + p * 12], delta=epsilon)
def test_sineWithOutlierTest(self):
""" generated source for method sineWithOutlierTest """
seed = 1234567
data = self.testDataGenerator.createNoisySeasonalData(144, 12, 1.0, 0.0, 0.0, seed)
data[100] = 1000
builder = SeasonalTrendLoess.Builder().setPeriodLength(12).setSeasonalWidth(1000000).setRobust()
smoother = builder.buildSmoother(data)
stl = smoother.decompose()
epsilon = 1.0e-4
trend = stl.getTrend()
seasonal = stl.getSeasonal()
residuals = stl.getResidual()
for i in range(len(data)):
if i != 100:
self.assertAlmostEqual(data[i], seasonal[i], msg="seasonal[{}]".format(i), delta=epsilon)
self.assertAlmostEqual(0.0, trend[i], msg="trend[{}]".format(i), delta=epsilon)
self.assertAlmostEqual(0.0, residuals[i], msg="residuals[{}]".format(i), delta=epsilon)
else:
self.assertAlmostEqual(data[i - 12], seasonal[i], msg="seasonal[{}]".format(i), delta=epsilon)
self.assertAlmostEqual(0.0, trend[i], msg="trend[{}]".format(i), delta=epsilon)
self.assertAlmostEqual(1.0, residuals[i] / 1000.0, msg="residuals[{}]".format(i), delta=1.0e-3)
def test_nullDataThrows(self):
""" generated source for method nullDataThrows """
with self.assertRaises(ValueError):
SeasonalTrendLoess.Builder().setPeriodLength(120).setSeasonalWidth(999).buildSmoother(None)
def test_periodicityMustBeAtLeastTwo(self):
""" generated source for method periodicityMustBeAtLeastTwo """
with self.assertRaises(ValueError):
SeasonalTrendLoess.Builder().setPeriodLength(1)
def test_dataMustHaveAtLeastTwoPeriods(self):
""" generated source for method dataMustHaveAtLeastTwoPeriods """
data = self.testDataGenerator.createNoisySeasonalData(144, 12, 1.0, 0.0, 0.0, 123)
with self.assertRaises(ValueError):
SeasonalTrendLoess.Builder().setPeriodLength(120).setSeasonalWidth(999).setNonRobust().buildSmoother(data)
def test_periodLengthMustBeSet(self):
""" generated source for method periodLengthMustBeSet """
with self.assertRaises(NameError):
SeasonalTrendLoess.Builder().setSeasonalWidth(999).buildSmoother(np.zeros(2000))
def test_getTestBuilder(self):
""" generated source for method getTestBuilder """
return SeasonalTrendLoess.Builder().setPeriodic().setPeriodLength(10)