Exemple #1
0
    def __init__(self, data, periodicity, ni, no, seasonalSettings,
                 trendSettings, lowpassSettings):

        self.fData = data

        size = len(data)

        self.fPeriodLength = periodicity
        self.fSeasonalSettings = seasonalSettings
        self.fTrendSettings = trendSettings
        self.fLowpassSettings = lowpassSettings
        self.fInnerIterations = ni
        self.fRobustIterations = no

        self.fLoessSmootherFactory = LoessSmoother.Builder()\
                                                  .setWidth(self.fTrendSettings.getWidth())\
                                                  .setDegree(self.fTrendSettings.getDegree())\
                                                  .setJump(self.fTrendSettings.getJump())

        self.fLowpassLoessFactory = LoessSmoother.Builder()\
                                                 .setWidth(self.fLowpassSettings.getWidth())\
                                                 .setDegree(self.fLowpassSettings.getDegree())\
                                                 .setJump(self.fLowpassSettings.getJump())

        self.fCyclicSubSeriesSmoother = CyclicSubSeriesSmoother.Builder()\
                                                               .setWidth(self.fSeasonalSettings.getWidth())\
                                                               .setDegree(self.fSeasonalSettings.getDegree())\
                                                               .setJump(self.fSeasonalSettings.getJump())\
                                                               .setDataLength(size)\
                                                               .extrapolateForwardAndBack(1)\
                                                               .setPeriodicity(periodicity)\
                                                               .build()
        self.fDetrend = np.zeros(size)
        self.fExtendedSeasonal = np.zeroes(size + 2 * fPeriodLength)
    def test_shouldExtrapolateTwoPeriodsBackwardAndTwoPeriodsForward(self):
        period = 24
        data = np.empty(2 * period)
        dx = float(2 * math.pi / period)

        for i in range(len(data)):
            amplitude = int(10 - i / period)
            data[i] = float(amplitude * math.sin(i * dx))

        extendedData = np.empty(6 * period)
        builder = CyclicSubSeriesSmoother.Builder()
        builder = builder.setWidth(
            7)  #Sub-cycle data is linear so width shouldn't matter
        builder = builder.setNumPeriodsForward(2).setNumPeriodsBackward(2)

        sssmoother = builder.setDataLength(
            len(data)).setPeriodicity(period).build()

        sssmoother.smoothSeasonal(data, extendedData, None)

        for i in range(len(extendedData)):
            amplitude = int(
                12 - i / period)  #Two extra for the extrapolation before.
            value = float(amplitude * math.sin(i * dx))
            self.assertAlmostEqual(value,
                                   extendedData[i],
                                   msg="test point {}".format(i),
                                   delta=1.0e-11)
 def test_widthMustBeSet(self):
     with self.assertRaises(ValueError):
         builder = CyclicSubSeriesSmoother.Builder()
         builder.setDataLength(100).extrapolateForwardAndBack(
             1).setPeriodicity(12).build()
 def test_degreeMustBeLessThanThree(self):
     with self.assertRaises(ValueError):
         builder = CyclicSubSeriesSmoother.Builder()
         builder.setDegree(3)
 def test_degreeMustBePositive(self):
     with self.assertRaises(ValueError):
         builder = CyclicSubSeriesSmoother.Builder()
         builder.setDegree(-1)
 def test_forwardExtrapolationMustBeSet(self):
     with self.assertRaises(ValueError):
         builder = CyclicSubSeriesSmoother.Builder()
         builder.setDataLength(100).setNumPeriodsBackward(1).setWidth(
             11).setPeriodicity(12).build()