├── src
    ├── TimeSeriesException.php
    ├── Predictors
    │   ├── TimeSeriesPredictor.php
    │   ├── HoltPredictor.php
    │   ├── MultiplicativeTrendPredictor.php
    │   ├── DampedHoltPredictor.php
    │   └── DampedMultiplicativeTrendPredictor.php
    └── Factories
    │   ├── PredictorFactory.php
    │   ├── HoltFactory.php
    │   ├── MultiplicativeTrendFactory.php
    │   ├── DampedHoltFactory.php
    │   ├── DampedMultiplicativeTrendFactory.php
    │   ├── BasicExponentialSmoothingFactory.php
    │   └── DampedExponentialSmoothingFactory.php
└── composer.json


/src/TimeSeriesException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | 
4 | namespace Litipk\TimeSeries;
5 | 
6 | 
7 | class TimeSeriesException extends \RuntimeException { }
8 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "litipk/php-timeseries",
 3 |     "description": "An open source time series forecasting library.",
 4 |     "license": "MIT",
 5 |     "authors": [
 6 |         {
 7 |             "name": "Andreu Correa Casablanca",
 8 |             "email": "castarco@litipk.com"
 9 |         }
10 |     ],
11 |     "support": {
12 |         "email": "castarco@litipk.com",
13 |         "issues": "http://github.com/Litipk/php-timeseries/issues",
14 |         "source": "http://github.com/Litipk/php-timeseries"
15 |     },
16 |     "minimum-stability": "stable",
17 |     "require": {},
18 |     "require-dev": {
19 |         "phpunit/phpunit": "^4.0"
20 |     },
21 |     "autoload": {
22 |         "psr-4": {
23 |             "Litipk\\TimeSeries\\": "src/"
24 |         }
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Predictors/TimeSeriesPredictor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Litipk\TimeSeries\Predictors;
 5 | 
 6 | 
 7 | /**
 8 |  * Interface TimeSeriesPredictor
 9 |  * @package Litipk\TimeSeries
10 |  */
11 | interface TimeSeriesPredictor
12 | {
13 |     /**
14 |      * @param double $dataPoint
15 |      */
16 |     public function ingestDataPoint($dataPoint);
17 | 
18 |     /**
19 |      * @param (null|double)[] $dataPoints
20 |      */
21 |     public function ingestDataArray(array $dataPoints);
22 | 
23 |     /**
24 |      * @param \Traversable $dataPoints
25 |      */
26 |     public function ingestDataTraversable(\Traversable $dataPoints);
27 | 
28 |     /**
29 |      * @param integer $nStepsToTheFuture
30 |      * @return double
31 |      */
32 |     public function predict($nStepsToTheFuture = 1);
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Factories/PredictorFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Litipk\TimeSeries\Factories;
 5 | 
 6 | 
 7 | use Litipk\TimeSeries\Predictors\TimeSeriesPredictor;
 8 | 
 9 | 
10 | /**
11 |  * Class TimeSeriesFactory
12 |  * @package Litipk\TimeSeries
13 |  */
14 | abstract class PredictorFactory
15 | {
16 |     /**
17 |      * @param array $dataPoints
18 |      * @return TimeSeriesPredictor
19 |      */
20 |     public abstract function train(array $dataPoints);
21 | 
22 | 
23 |     /**
24 |      * @return PredictorFactory
25 |      */
26 |     protected static function getDefaultInstance()
27 |     {
28 |         throw new \RuntimeException('Not implemented. Should be implemented by the subclasses');
29 |     }
30 | 
31 |     /**
32 |      * @param array $dataPoints
33 |      * @return TimeSeriesPredictor
34 |      */
35 |     public static function trainPredictor(array $dataPoints)
36 |     {
37 |         return static::getDefaultInstance()->train($dataPoints);
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Factories/HoltFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Litipk\TimeSeries\Factories;
 5 | 
 6 | 
 7 | use Litipk\TimeSeries\Predictors\HoltPredictor;
 8 | 
 9 | 
10 | /**
11 |  * Class HoltFactory
12 |  * @package Litipk\TimeSeries
13 |  */
14 | class HoltFactory extends BasicExponentialSmoothingFactory
15 | {
16 |     /** @var  HoltFactory */
17 |     private static $defaultInstance = null;
18 | 
19 |     /**
20 |      * @param integer $nStepsPerParam
21 |      */
22 |     public function __construct($nStepsPerParam)
23 |     {
24 |         parent::__construct($nStepsPerParam);
25 |     }
26 | 
27 |     /**
28 |      * @return PredictorFactory
29 |      */
30 |     protected static function getDefaultInstance()
31 |     {
32 |         if (null === static::$defaultInstance) {
33 |             static::$defaultInstance = new static(101);
34 |         }
35 |         return static::$defaultInstance;
36 |     }
37 | 
38 |     /**
39 |      * @param double $alpha
40 |      * @param double $beta
41 |      * @param double $level
42 |      * @return HoltPredictor
43 |      */
44 |     protected function getPredictor($alpha, $beta, $level)
45 |     {
46 |         return new HoltPredictor($alpha, $beta, $level);
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/Factories/MultiplicativeTrendFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Litipk\TimeSeries\Factories;
 5 | 
 6 | 
 7 | use Litipk\TimeSeries\Predictors\MultiplicativeTrendPredictor;
 8 | 
 9 | 
10 | /**
11 |  * Class HoltFactory
12 |  * @package Litipk\TimeSeries
13 |  */
14 | class MultiplicativeTrendFactory extends BasicExponentialSmoothingFactory
15 | {
16 |     /** @var  MultiplicativeTrendFactory */
17 |     private static $defaultInstance = null;
18 | 
19 |     /**
20 |      * @param integer $nStepsPerParam
21 |      */
22 |     public function __construct($nStepsPerParam)
23 |     {
24 |         parent::__construct($nStepsPerParam);
25 |     }
26 | 
27 |     /**
28 |      * @return PredictorFactory
29 |      */
30 |     protected static function getDefaultInstance()
31 |     {
32 |         if (null === static::$defaultInstance) {
33 |             static::$defaultInstance = new static(101);
34 |         }
35 |         return static::$defaultInstance;
36 |     }
37 | 
38 |     /**
39 |      * @param double $alpha
40 |      * @param double $beta
41 |      * @param double $level
42 |      * @return MultiplicativeTrendPredictor
43 |      */
44 |     protected function getPredictor($alpha, $beta, $level)
45 |     {
46 |         return new MultiplicativeTrendPredictor($alpha, $beta, $level);
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/Factories/DampedHoltFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Litipk\TimeSeries\Factories;
 5 | 
 6 | 
 7 | use Litipk\TimeSeries\Predictors\DampedHoltPredictor;
 8 | 
 9 | 
10 | /**
11 |  * Class HoltFactory
12 |  * @package Litipk\TimeSeries
13 |  */
14 | class DampedHoltFactory extends DampedExponentialSmoothingFactory
15 | {
16 |     /** @var  HoltFactory */
17 |     private static $defaultInstance = null;
18 | 
19 |     /**
20 |      * @param integer $nStepsPerParam
21 |      * @param integer $predictionHorizon
22 |      */
23 |     public function __construct($nStepsPerParam, $predictionHorizon)
24 |     {
25 |         parent::__construct($nStepsPerParam, $predictionHorizon);
26 |     }
27 | 
28 |     /**
29 |      * @return PredictorFactory
30 |      */
31 |     protected static function getDefaultInstance()
32 |     {
33 |         if (null === static::$defaultInstance) {
34 |             static::$defaultInstance = new static(101, +INF);
35 |         }
36 |         return static::$defaultInstance;
37 |     }
38 | 
39 | 
40 |     /**
41 |      * @param double $alpha
42 |      * @param double $beta
43 |      * @param double $theta
44 |      * @param double $level
45 |      * @return DampedHoltPredictor
46 |      */
47 |     protected function getPredictor($alpha, $beta, $theta, $level)
48 |     {
49 |         return new DampedHoltPredictor($alpha, $beta, $theta, $level);
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/src/Factories/DampedMultiplicativeTrendFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Litipk\TimeSeries\Factories;
 5 | 
 6 | 
 7 | use Litipk\TimeSeries\Predictors\DampedMultiplicativeTrendPredictor;
 8 | 
 9 | 
10 | /**
11 |  * Class HoltFactory
12 |  * @package Litipk\TimeSeries
13 |  */
14 | class DampedMultiplicativeTrendFactory extends DampedExponentialSmoothingFactory
15 | {
16 |     /** @var  HoltFactory */
17 |     private static $defaultInstance = null;
18 | 
19 |     /**
20 |      * @param integer $nStepsPerParam
21 |      * @param integer $predictionHorizon
22 |      */
23 |     public function __construct($nStepsPerParam, $predictionHorizon)
24 |     {
25 |         parent::__construct($nStepsPerParam, $predictionHorizon);
26 |     }
27 | 
28 |     /**
29 |      * @return PredictorFactory
30 |      */
31 |     protected static function getDefaultInstance()
32 |     {
33 |         if (null === static::$defaultInstance) {
34 |             static::$defaultInstance = new static(101, +INF);
35 |         }
36 |         return static::$defaultInstance;
37 |     }
38 | 
39 |     /**
40 |      * @param double $alpha
41 |      * @param double $beta
42 |      * @param double $theta
43 |      * @param double $level
44 |      * @return DampedMultiplicativeTrendPredictor
45 |      */
46 |     protected function getPredictor($alpha, $beta, $theta, $level)
47 |     {
48 |         return new DampedMultiplicativeTrendPredictor($alpha, $beta, $theta, $level);
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/src/Factories/BasicExponentialSmoothingFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Litipk\TimeSeries\Factories;
 5 | 
 6 | 
 7 | use Litipk\TimeSeries\Predictors\TimeSeriesPredictor;
 8 | use Litipk\TimeSeries\TimeSeriesException;
 9 | 
10 | 
11 | /**
12 |  * Class HoltFactory
13 |  * @package Litipk\TimeSeries
14 |  */
15 | abstract class BasicExponentialSmoothingFactory extends PredictorFactory
16 | {
17 |     /** @var  integer */
18 |     private $nStepsPerParam;
19 | 
20 |     /**
21 |      * @param integer $nStepsPerParam
22 |      */
23 |     protected function __construct($nStepsPerParam)
24 |     {
25 |         $this->nStepsPerParam = (int)max(2, $nStepsPerParam);
26 |     }
27 | 
28 |     /**
29 |      * @param array $dataPoints
30 |      * @return TimeSeriesPredictor
31 |      */
32 |     public function train(array $dataPoints)
33 |     {
34 |         $dataSetSize = \count($dataPoints);
35 |         if ($dataSetSize < 4) {
36 |             throw new TimeSeriesException('Insufficient number of data points');
37 |         }
38 | 
39 |         $minError = +INF;
40 |         $bestPredictor = null;
41 | 
42 |         // Local variables to avoid too many indirections
43 |         $nStepsPerParam = $this->nStepsPerParam;
44 |         $stepSize = 1./($nStepsPerParam-1);
45 |         $firstLevel = $dataPoints[0];
46 | 
47 |         for ($i=0; $i<$nStepsPerParam; $i++) {
48 |             for ($j=0; $j<$nStepsPerParam; $j++) {
49 |                 $candidate = $this->getPredictor($i*$stepSize, $j*$stepSize, $firstLevel);
50 |                 $candidateError = 0.0;
51 | 
52 |                 for ($k=1; $k<$dataSetSize; $k++) {
53 |                     $candidateError += \pow($candidate->predict()-$dataPoints[$k], 2);
54 |                     $candidate->ingestDataPoint($dataPoints[$k]);
55 |                 }
56 | 
57 |                 if ($candidateError < $minError) {
58 |                     $minError = $candidateError;
59 |                     $bestPredictor = $candidate;
60 |                 }
61 |             }
62 |         }
63 | 
64 |         return $bestPredictor;
65 |     }
66 | 
67 |     /**
68 |      * @param double $alpha
69 |      * @param double $beta
70 |      * @param double $level
71 |      * @return TimeSeriesPredictor
72 |      */
73 |     protected abstract function getPredictor($alpha, $beta, $level);
74 | }
75 | 


--------------------------------------------------------------------------------
/src/Factories/DampedExponentialSmoothingFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Litipk\TimeSeries\Factories;
 5 | 
 6 | 
 7 | use Litipk\TimeSeries\TimeSeriesException;
 8 | use Litipk\TimeSeries\Predictors\TimeSeriesPredictor;
 9 | 
10 | 
11 | /**
12 |  * Class DampedExponentialSmoothingFactory
13 |  * @package Litipk\TimeSeries
14 |  */
15 | abstract class DampedExponentialSmoothingFactory extends PredictorFactory
16 | {
17 |     /** @var  integer */
18 |     private $nStepsPerParam;
19 | 
20 |     /** @var  integer */
21 |     private $predictionHorizon;
22 | 
23 |     /**
24 |      * @param integer $nStepsPerParam
25 |      * @param integer $predictionHorizon
26 |      */
27 |     protected function __construct($nStepsPerParam, $predictionHorizon)
28 |     {
29 |         $this->nStepsPerParam = (int)max(2, $nStepsPerParam);
30 |         $this->predictionHorizon = is_infinite($predictionHorizon) ?
31 |             +INF : (int)ceil(max(2, $predictionHorizon));
32 |     }
33 | 
34 |     /**
35 |      * @param array $dataPoints
36 |      * @return DampedHoltFactory
37 |      */
38 |     public function train(array $dataPoints)
39 |     {
40 |         $dataSetSize = count($dataPoints);
41 |         if ($dataSetSize < 6) {
42 |             throw new TimeSeriesException('Insufficient number of data points');
43 |         }
44 | 
45 |         $minError = +INF;
46 |         $bestPredictor = null;
47 | 
48 |         // Local variables to avoid too many indirections
49 |         $nStepsPerParam = $this->nStepsPerParam;
50 |         $stepSize = 1./($nStepsPerParam-1);
51 |         $firstLevel = $dataPoints[0];
52 | 
53 |         for ($i=0; $i<$nStepsPerParam; $i++) {
54 |             for ($j=0; $j<$nStepsPerParam; $j++) {
55 |                 for ($k=1; $k<$nStepsPerParam; $k+=2) {
56 |                     $candidate = $this->getPredictor($i*$stepSize, $j*$stepSize, $k*$stepSize, $firstLevel);
57 |                     $candidateError = 0.0;
58 | 
59 |                     for ($u=1; $u<$dataSetSize; $u++) {
60 |                         for ($v=0; $v<$this->predictionHorizon && $u+$v<$dataSetSize; $v++) {
61 |                             $candidateError += pow($candidate->predict($v+1)-$dataPoints[$u+$v], 2);
62 |                         }
63 |                         $candidate->ingestDataPoint($dataPoints[$u]);
64 |                     }
65 | 
66 |                     if ($candidateError < $minError) {
67 |                         $minError = $candidateError;
68 |                         $bestPredictor = $candidate;
69 |                     }
70 |                 }
71 |             }
72 |         }
73 | 
74 |         return $bestPredictor;
75 |     }
76 | 
77 |     /**
78 |      * @param double $alpha
79 |      * @param double $beta
80 |      * @param double $theta
81 |      * @param double $level
82 |      * @return TimeSeriesPredictor
83 |      */
84 |     abstract protected function getPredictor($alpha, $beta, $theta, $level);
85 | }
86 | 


--------------------------------------------------------------------------------
/src/Predictors/HoltPredictor.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | 
  4 | namespace Litipk\TimeSeries\Predictors;
  5 | 
  6 | 
  7 | /**
  8 |  * Class HoltPredictor
  9 |  * @package Litipk\PhpTimeSeries
 10 |  */
 11 | class HoltPredictor implements TimeSeriesPredictor
 12 | {
 13 |     /** @var  double */
 14 |     private $alpha;
 15 | 
 16 |     /** @var  double */
 17 |     private $beta;
 18 | 
 19 |     /** @var  double */
 20 |     private $level;
 21 | 
 22 |     /** @var  double */
 23 |     private $trend;
 24 | 
 25 |     /**
 26 |      * @param double $alpha Level learning rate
 27 |      * @param double $beta  Trend learning rate
 28 |      * @param double $level
 29 |      * @param double $trend
 30 |      */
 31 |     public function __construct($alpha, $beta, $level, $trend = 0.0)
 32 |     {
 33 |         $this->alpha = (double)\min(1.0, \max(0.0, $alpha));
 34 |         $this->beta = (double)\min(1.0, \max(0.0, $beta));
 35 | 
 36 |         $this->level = (double)$level;
 37 |         $this->trend = (double)$trend;
 38 |     }
 39 | 
 40 | 
 41 |     /**
 42 |      * @param (null|double)[] $dataPoints
 43 |      */
 44 |     public function ingestDataArray(array $dataPoints)
 45 |     {
 46 |         $this->ingestData($dataPoints);
 47 |     }
 48 | 
 49 |     /**
 50 |      * @param \Traversable $dataPoints
 51 |      */
 52 |     public function ingestDataTraversable(\Traversable $dataPoints)
 53 |     {
 54 |         $this->ingestData($dataPoints);
 55 |     }
 56 | 
 57 |     /**
 58 |      * @param integer $nStepsToTheFuture
 59 |      * @return double
 60 |      */
 61 |     public function predict($nStepsToTheFuture = 1)
 62 |     {
 63 |         return $this->level + $nStepsToTheFuture*$this->trend;
 64 |     }
 65 | 
 66 |     /**
 67 |      * @return float
 68 |      */
 69 |     public function getLevel()
 70 |     {
 71 |         return $this->level;
 72 |     }
 73 | 
 74 |     /**
 75 |      * @return float
 76 |      */
 77 |     public function getTrend()
 78 |     {
 79 |         return $this->trend;
 80 |     }
 81 | 
 82 |     /**
 83 |      * @return float Level learning rate
 84 |      */
 85 |     public function getAlpha()
 86 |     {
 87 |         return $this->alpha;
 88 |     }
 89 | 
 90 |     /**
 91 |      * @return float Trend learning rate
 92 |      */
 93 |     public function getBeta()
 94 |     {
 95 |         return $this->beta;
 96 |     }
 97 | 
 98 |     /**
 99 |      * @param double $dataPoint
100 |      */
101 |     public function ingestDataPoint($dataPoint)
102 |     {
103 |         $chgFactor = $this->alpha*($dataPoint - $this->level - $this->trend);
104 |         $this->level = $this->level + $this->trend + $chgFactor;
105 |         $this->trend = $this->trend + $this->beta*$chgFactor;
106 |     }
107 | 
108 |     /**
109 |      * @param array|\Traversable $dataPoints
110 |      */
111 |     private function ingestData($dataPoints)
112 |     {
113 |         // We don't use $this->ingestDataPoint for performance reasons
114 |         foreach ($dataPoints as $dataPoint) {
115 |             $chgFactor = $this->alpha*($dataPoint - $this->level - $this->trend);
116 |             $this->level = $this->level + $this->trend + $chgFactor;
117 |             $this->trend = $this->trend + $this->beta*$chgFactor;
118 |         }
119 |     }
120 | }
121 | 


--------------------------------------------------------------------------------
/src/Predictors/MultiplicativeTrendPredictor.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | 
  4 | namespace Litipk\TimeSeries\Predictors;
  5 | 
  6 | 
  7 | use Litipk\TimeSeries\TimeSeriesException;
  8 | 
  9 | 
 10 | /**
 11 |  * Class MultiplicativeTrendPredictor
 12 |  * @package Litipk\PhpTimeSeries
 13 |  */
 14 | class MultiplicativeTrendPredictor implements TimeSeriesPredictor
 15 | {
 16 |     /** @var  double */
 17 |     private $alpha;
 18 | 
 19 |     /** @var  double */
 20 |     private $beta;
 21 | 
 22 |     /** @var  double */
 23 |     private $level;
 24 | 
 25 |     /** @var  double */
 26 |     private $trend;
 27 | 
 28 |     /**
 29 |      * @param double $alpha Level learning rate
 30 |      * @param double $beta  Trend learning rate
 31 |      * @param double $level
 32 |      * @param double $trend
 33 |      */
 34 |     public function __construct($alpha, $beta, $level, $trend = 1.0)
 35 |     {
 36 |         if (!is_numeric($alpha) || !is_numeric($beta) || !is_numeric($level) || !is_numeric($trend)) {
 37 |             throw new TimeSeriesException('Invalid parameter types');
 38 |         }
 39 | 
 40 |         if ($alpha < 0.0  || $alpha > 1.0 || $beta < 0.0 || $beta > 1.0) {
 41 |             throw new TimeSeriesException('Alpha and Beta must be in the [0, 1] interval');
 42 |         }
 43 | 
 44 |         $this->alpha = (double)$alpha;
 45 |         $this->beta = (double)$beta;
 46 | 
 47 |         $this->level = (double)$level;
 48 |         $this->trend = (double)$trend;
 49 |     }
 50 | 
 51 | 
 52 |     /**
 53 |      * @param (null|double)[] $dataPoints
 54 |      */
 55 |     public function ingestDataArray(array $dataPoints)
 56 |     {
 57 |         $this->ingestData($dataPoints);
 58 |     }
 59 | 
 60 |     /**
 61 |      * @param \Traversable $dataPoints
 62 |      */
 63 |     public function ingestDataTraversable(\Traversable $dataPoints)
 64 |     {
 65 |         $this->ingestData($dataPoints);
 66 |     }
 67 | 
 68 |     /**
 69 |      * @param integer $nStepsToTheFuture
 70 |      * @return double
 71 |      */
 72 |     public function predict($nStepsToTheFuture = 1)
 73 |     {
 74 |         return $this->level*pow($this->trend, $nStepsToTheFuture);
 75 |     }
 76 | 
 77 |     /**
 78 |      * @return float
 79 |      */
 80 |     public function getLevel()
 81 |     {
 82 |         return $this->level;
 83 |     }
 84 | 
 85 |     /**
 86 |      * @return float
 87 |      */
 88 |     public function getTrend()
 89 |     {
 90 |         return $this->trend;
 91 |     }
 92 | 
 93 |     /**
 94 |      * @return float Level learning rate
 95 |      */
 96 |     public function getAlpha()
 97 |     {
 98 |         return $this->alpha;
 99 |     }
100 | 
101 |     /**
102 |      * @return float Trend learning rate
103 |      */
104 |     public function getBeta()
105 |     {
106 |         return $this->beta;
107 |     }
108 | 
109 |     /**
110 |      * @param double $dataPoint
111 |      */
112 |     public function ingestDataPoint($dataPoint)
113 |     {
114 |         $chgFactor = $this->alpha*($dataPoint - $this->level*$this->trend);
115 |         $previousLevel = $this->level;
116 |         $this->level = $this->level*$this->trend + $chgFactor;
117 |         $this->trend = $this->trend + $this->beta*$chgFactor/$previousLevel;
118 |     }
119 | 
120 |     /**
121 |      * @param array|\Traversable $dataPoints
122 |      */
123 |     private function ingestData($dataPoints)
124 |     {
125 |         // We don't use $this->ingestDataPoint for performance reasons
126 |         foreach ($dataPoints as $dataPoint) {
127 |             $chgFactor = $this->alpha*($dataPoint - $this->level*$this->trend);
128 |             $previousLevel = $this->level;
129 |             $this->level = $this->level*$this->trend + $chgFactor;
130 |             $this->trend = $this->trend + $this->beta*$chgFactor/$previousLevel;
131 |         }
132 |     }
133 | }
134 | 


--------------------------------------------------------------------------------
/src/Predictors/DampedHoltPredictor.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | 
  4 | namespace Litipk\TimeSeries\Predictors;
  5 | 
  6 | 
  7 | use Litipk\TimeSeries\TimeSeriesException;
  8 | 
  9 | 
 10 | /**
 11 |  * Class DampedHoltPredictor
 12 |  * @package Litipk\PhpTimeSeries
 13 |  */
 14 | class DampedHoltPredictor implements TimeSeriesPredictor
 15 | {
 16 |     /** @var  double */
 17 |     private $alpha;
 18 | 
 19 |     /** @var  double */
 20 |     private $beta;
 21 | 
 22 |     /** @var  double */
 23 |     private $theta;
 24 | 
 25 |     /** @var  double */
 26 |     private $level;
 27 | 
 28 |     /** @var  double */
 29 |     private $trend;
 30 | 
 31 |     /**
 32 |      * @param double $alpha Level learning rate
 33 |      * @param double $beta  Trend learning rate
 34 |      * @param double $theta Damping factor
 35 |      * @param double $level
 36 |      * @param double $trend
 37 |      */
 38 |     public function __construct($alpha, $beta, $theta, $level, $trend = 0.0)
 39 |     {
 40 |         if ($theta <= 0.0 || $theta > 1.0) {
 41 |             throw new TimeSeriesException('Theta must be in the (0, 1] interval');
 42 |         }
 43 | 
 44 |         $this->alpha = (double)min(max(0.0, $alpha), 1.0);
 45 |         $this->beta = (double)min(max(0.0, $beta), 1.0);
 46 |         $this->theta = (double)$theta;
 47 | 
 48 |         $this->level = (double)$level;
 49 |         $this->trend = (double)$trend;
 50 |     }
 51 | 
 52 | 
 53 |     /**
 54 |      * @param (null|double)[] $dataPoints
 55 |      */
 56 |     public function ingestDataArray(array $dataPoints)
 57 |     {
 58 |         $this->ingestData($dataPoints);
 59 |     }
 60 | 
 61 |     /**
 62 |      * @param \Traversable $dataPoints
 63 |      */
 64 |     public function ingestDataTraversable(\Traversable $dataPoints)
 65 |     {
 66 |         $this->ingestData($dataPoints);
 67 |     }
 68 | 
 69 |     /**
 70 |      * @param integer $nStepsToTheFuture
 71 |      * @return double
 72 |      */
 73 |     public function predict($nStepsToTheFuture = 1)
 74 |     {
 75 |         $m = 0;
 76 |         $t = 1;
 77 | 
 78 |         for ($i=0; $i<$nStepsToTheFuture; $i++) {
 79 |             $t *= $this->theta;
 80 |             $m += $t;
 81 |         }
 82 | 
 83 |         return $this->level + $m*$this->trend;
 84 |     }
 85 | 
 86 |     /**
 87 |      * @return float
 88 |      */
 89 |     public function getLevel()
 90 |     {
 91 |         return $this->level;
 92 |     }
 93 | 
 94 |     /**
 95 |      * @return float
 96 |      */
 97 |     public function getTrend()
 98 |     {
 99 |         return $this->trend;
100 |     }
101 | 
102 |     /**
103 |      * @return float Level learning rate
104 |      */
105 |     public function getAlpha()
106 |     {
107 |         return $this->alpha;
108 |     }
109 | 
110 |     /**
111 |      * @return float Trend learning rate
112 |      */
113 |     public function getBeta()
114 |     {
115 |         return $this->beta;
116 |     }
117 | 
118 |     /**
119 |      * @return float Damping factor
120 |      */
121 |     public function getTheta()
122 |     {
123 |         return $this->theta;
124 |     }
125 | 
126 |     /**
127 |      * @param double $dataPoint
128 |      */
129 |     public function ingestDataPoint($dataPoint)
130 |     {
131 |         $tt = $this->theta*$this->trend;
132 |         $chgFactor = $this->alpha*($dataPoint - $this->level - $tt);
133 | 
134 |         $this->level = $this->level + $tt + $chgFactor;
135 |         $this->trend = $tt + $this->beta*$chgFactor;
136 |     }
137 | 
138 |     /**
139 |      * @param array|\Traversable $dataPoints
140 |      */
141 |     private function ingestData($dataPoints)
142 |     {
143 |         // We don't use $this->ingestDataPoint for performance reasons
144 |         foreach ($dataPoints as $dataPoint) {
145 |             $tt = $this->theta*$this->trend;
146 |             $chgFactor = $this->alpha*($dataPoint - $this->level - $tt);
147 | 
148 |             $this->level = $this->level + $tt + $chgFactor;
149 |             $this->trend = $tt + $this->beta*$chgFactor;
150 |         }
151 |     }
152 | }
153 | 


--------------------------------------------------------------------------------
/src/Predictors/DampedMultiplicativeTrendPredictor.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | 
  4 | namespace Litipk\TimeSeries\Predictors;
  5 | 
  6 | 
  7 | use Litipk\TimeSeries\TimeSeriesException;
  8 | 
  9 | 
 10 | /**
 11 |  * Class DampedMultiplicativeTrendPredictor
 12 |  * @package Litipk\PhpTimeSeries
 13 |  */
 14 | class DampedMultiplicativeTrendPredictor implements TimeSeriesPredictor
 15 | {
 16 |     /** @var  double */
 17 |     private $alpha;
 18 | 
 19 |     /** @var  double */
 20 |     private $beta;
 21 | 
 22 |     /** @var  double */
 23 |     private $theta;
 24 | 
 25 |     /** @var  double */
 26 |     private $level;
 27 | 
 28 |     /** @var  double */
 29 |     private $trend;
 30 | 
 31 |     /**
 32 |      * @param double $alpha Level learning rate
 33 |      * @param double $beta  Trend learning rate
 34 |      * @param double $theta Damping factor
 35 |      * @param double $level
 36 |      * @param double $trend
 37 |      */
 38 |     public function __construct($alpha, $beta, $theta, $level, $trend = 1.0)
 39 |     {
 40 |         if ($theta <= 0.0 || $theta > 1.0) {
 41 |             throw new TimeSeriesException('Theta must be in the (0, 1] interval');
 42 |         }
 43 | 
 44 |         $this->alpha = (double)min(max(0.0, $alpha), 1.0);
 45 |         $this->beta = (double)min(max(0.0, $beta), 1.0);
 46 |         $this->theta = (double)$theta;
 47 | 
 48 |         $this->level = (double)$level;
 49 |         $this->trend = (double)$trend;
 50 |     }
 51 | 
 52 | 
 53 |     /**
 54 |      * @param (null|double)[] $dataPoints
 55 |      */
 56 |     public function ingestDataArray(array $dataPoints)
 57 |     {
 58 |         $this->ingestData($dataPoints);
 59 |     }
 60 | 
 61 |     /**
 62 |      * @param \Traversable $dataPoints
 63 |      */
 64 |     public function ingestDataTraversable(\Traversable $dataPoints)
 65 |     {
 66 |         $this->ingestData($dataPoints);
 67 |     }
 68 | 
 69 |     /**
 70 |      * @param integer $nStepsToTheFuture
 71 |      * @return double
 72 |      */
 73 |     public function predict($nStepsToTheFuture = 1)
 74 |     {
 75 |         $m = 0;
 76 |         $t = 1;
 77 | 
 78 |         for ($i=0; $i<$nStepsToTheFuture; $i++) {
 79 |             $t *= $this->theta;
 80 |             $m += $t;
 81 |         }
 82 | 
 83 |         return $this->level * pow($this->trend, $m);
 84 |     }
 85 | 
 86 |     /**
 87 |      * @return float
 88 |      */
 89 |     public function getLevel()
 90 |     {
 91 |         return $this->level;
 92 |     }
 93 | 
 94 |     /**
 95 |      * @return float
 96 |      */
 97 |     public function getTrend()
 98 |     {
 99 |         return $this->trend;
100 |     }
101 | 
102 |     /**
103 |      * @return float Level learning rate
104 |      */
105 |     public function getAlpha()
106 |     {
107 |         return $this->alpha;
108 |     }
109 | 
110 |     /**
111 |      * @return float Trend learning rate
112 |      */
113 |     public function getBeta()
114 |     {
115 |         return $this->beta;
116 |     }
117 | 
118 |     /**
119 |      * @return float Damping factor
120 |      */
121 |     public function getTheta()
122 |     {
123 |         return $this->theta;
124 |     }
125 | 
126 |     /**
127 |      * @param double $dataPoint
128 |      */
129 |     public function ingestDataPoint($dataPoint)
130 |     {
131 |         $tt = pow($this->trend, $this->theta);
132 |         $chgFactor = $this->alpha*($dataPoint - $this->level*$tt);
133 | 
134 |         $previousLevel = $this->level;
135 | 
136 |         $this->level = $this->level*$tt + $chgFactor;
137 |         $this->trend = $tt + $this->beta*$chgFactor/$previousLevel;
138 |     }
139 | 
140 |     /**
141 |      * @param array|\Traversable $dataPoints
142 |      */
143 |     private function ingestData($dataPoints)
144 |     {
145 |         // We don't use $this->ingestDataPoint for performance reasons
146 |         foreach ($dataPoints as $dataPoint) {
147 |             $tt = pow($this->trend, $this->theta);
148 |             $chgFactor = $this->alpha*($dataPoint - $this->level*$tt);
149 | 
150 |             $previousLevel = $this->level;
151 | 
152 |             $this->level = $this->level*$tt + $chgFactor;
153 |             $this->trend = $tt + $this->beta*$chgFactor/$previousLevel;
154 |         }
155 |     }
156 | }
157 | 


--------------------------------------------------------------------------------