Better naming of decomposition methods and related variables

Author: tveasey

include/maths/CTimeSeriesDecomposition.h

@@ -118,19 +118,19 @@ class MATHS_EXPORT CTimeSeriesDecomposition : public CTimeSeriesDecompositionInt
         //! Propagate the decomposition forwards to \p time.
         void propagateForwardsTo(core_t::TTime time);
 
-        //! Get the mean value of the baseline in the vicinity of \p time.
-        virtual double mean(core_t::TTime time) const;
+        //! Get the mean value of the time series in the vicinity of \p time.
+        virtual double meanValue(core_t::TTime time) const;
 
-        //! Get the value of the time series baseline at \p time.
+        //! Get the value of the time series at \p time.
         //!
         //! \param[in] time The time of interest.
         //! \param[in] confidence The symmetric confidence interval for the prediction
         //! the baseline as a percentage.
         //! \param[in] components The components to include in the baseline.
-        virtual maths_t::TDoubleDoublePr baseline(core_t::TTime time,
-                                                  double confidence = 0.0,
-                                                  int components = E_All,
-                                                  bool smooth = true) const;
+        virtual maths_t::TDoubleDoublePr value(core_t::TTime time,
+                                               double confidence = 0.0,
+                                               int components = E_All,
+                                               bool smooth = true) const;
 
         //! Forecast from \p start to \p end at \p dt intervals.
         //!

include/maths/CTimeSeriesDecompositionInterface.h

@@ -90,19 +90,19 @@ class MATHS_EXPORT CTimeSeriesDecompositionInterface
         //! Propagate the decomposition forwards to \p time.
         virtual void propagateForwardsTo(core_t::TTime time) = 0;
 
-        //! Get the mean value of the baseline in the vicinity of \p time.
-        virtual double mean(core_t::TTime time) const = 0;
+        //! Get the mean value of the time series in the vicinity of \p time.
+        virtual double meanValue(core_t::TTime time) const = 0;
 
-        //! Get the value of the time series baseline at \p time.
+        //! Get the value of the time series at \p time.
         //!
         //! \param[in] time The time of interest.
         //! \param[in] confidence The symmetric confidence interval for the prediction
         //! the baseline as a percentage.
         //! \param[in] components The components to include in the baseline.
-        virtual maths_t::TDoubleDoublePr baseline(core_t::TTime time,
-                                                  double confidence = 0.0,
-                                                  int components = E_All,
-                                                  bool smooth = true) const = 0;
+        virtual maths_t::TDoubleDoublePr value(core_t::TTime time,
+                                               double confidence = 0.0,
+                                               int components = E_All,
+                                               bool smooth = true) const = 0;
 
         //! Forecast from \p start to \p end at \p dt intervals.
         //!

include/maths/CTimeSeriesDecompositionStub.h

@@ -47,13 +47,13 @@ class MATHS_EXPORT CTimeSeriesDecompositionStub : public CTimeSeriesDecompositio
         virtual void propagateForwardsTo(core_t::TTime time);
 
         //! Returns 0.
-        virtual double mean(core_t::TTime time) const;
+        virtual double meanValue(core_t::TTime time) const;
 
         //! Returns (0.0, 0.0).
-        virtual maths_t::TDoubleDoublePr baseline(core_t::TTime time,
-                                                  double confidence = 0.0,
-                                                  int components = E_All,
-                                                  bool smooth = true) const;
+        virtual maths_t::TDoubleDoublePr value(core_t::TTime time,
+                                               double confidence = 0.0,
+                                               int components = E_All,
+                                               bool smooth = true) const;
 
         //! Clears \p result.
         virtual void forecast(core_t::TTime startTime,

lib/maths/CTimeSeriesDecomposition.cc

@@ -243,13 +243,12 @@ bool CTimeSeriesDecomposition::addPoint(core_t::TTime time,
     this->propagateForwardsTo(time);
 
     SAddValue message{time, lastTime, value, weightStyles, weights,
-                      CBasicStatistics::mean(this->baseline(time, 0.0, E_TrendForced)),
-                      CBasicStatistics::mean(this->baseline(time, 0.0, E_Seasonal)),
-                      CBasicStatistics::mean(this->baseline(time, 0.0, E_Calendar)),
+                      CBasicStatistics::mean(this->value(time, 0.0, E_TrendForced)),
+                      CBasicStatistics::mean(this->value(time, 0.0, E_Seasonal)),
+                      CBasicStatistics::mean(this->value(time, 0.0, E_Calendar)),
                       [this](core_t::TTime time_)
                       {
-                          return CBasicStatistics::mean(this->baseline(
-                                     time_, 0.0, E_Seasonal | E_Calendar));
+                          return CBasicStatistics::mean(this->value(time_, 0.0, E_Seasonal | E_Calendar));
                       },
                       m_Components.periodicityTestConfig()};
 
@@ -271,15 +270,15 @@ void CTimeSeriesDecomposition::propagateForwardsTo(core_t::TTime time)
     m_LastPropagationTime = std::max(m_LastPropagationTime, time);
 }
 
-double CTimeSeriesDecomposition::mean(core_t::TTime time) const
+double CTimeSeriesDecomposition::meanValue(core_t::TTime time) const
 {
     return m_Components.meanValue(time);
 }
 
-TDoubleDoublePr CTimeSeriesDecomposition::baseline(core_t::TTime time,
-                                                   double confidence,
-                                                   int components,
-                                                   bool smooth) const
+TDoubleDoublePr CTimeSeriesDecomposition::value(core_t::TTime time,
+                                                double confidence,
+                                                int components,
+                                                bool smooth) const
 {
     TVector2x1 baseline{0.0};
 
@@ -320,7 +319,7 @@ TDoubleDoublePr CTimeSeriesDecomposition::baseline(core_t::TTime time,
     if (smooth)
     {
         baseline += vector2x1(this->smooth(
-                boost::bind(&CTimeSeriesDecomposition::baseline,
+                boost::bind(&CTimeSeriesDecomposition::value,
                             this, _1, confidence, components & E_Seasonal, false),
                 time, components));
     }
@@ -399,8 +398,8 @@ double CTimeSeriesDecomposition::detrend(core_t::TTime time, double value, doubl
     {
         return value;
     }
-    TDoubleDoublePr baseline{this->baseline(time, confidence)};
-    return std::min(value - baseline.first, 0.0) + std::max(value - baseline.second, 0.0);
+    TDoubleDoublePr interval{this->value(time, confidence)};
+    return std::min(value - interval.first, 0.0) + std::max(value - interval.second, 0.0);
 }
 
 double CTimeSeriesDecomposition::meanVariance(void) const

lib/maths/CTimeSeriesDecompositionStub.cc

@@ -48,15 +48,15 @@ void CTimeSeriesDecompositionStub::propagateForwardsTo(core_t::TTime /*time*/)
 {
 }
 
-double CTimeSeriesDecompositionStub::mean(core_t::TTime /*time*/) const
+double CTimeSeriesDecompositionStub::meanValue(core_t::TTime /*time*/) const
 {
     return 0.0;
 }
 
-maths_t::TDoubleDoublePr CTimeSeriesDecompositionStub::baseline(core_t::TTime /*time*/,
-                                                                double /*confidence*/,
-                                                                int /*components*/,
-                                                                bool /*smooth*/) const
+maths_t::TDoubleDoublePr CTimeSeriesDecompositionStub::value(core_t::TTime /*time*/,
+                                                             double /*confidence*/,
+                                                             int /*components*/,
+                                                             bool /*smooth*/) const
 {
     return {0.0, 0.0};
 }

lib/maths/CTimeSeriesModel.cc

@@ -764,8 +764,8 @@ CUnivariateTimeSeriesModel::addSamples(const CModelAddSamplesParams &params,
         {
             CDecayRateController &controller{(*m_Controllers)[E_TrendControl]};
             core_t::TTime time{static_cast<core_t::TTime>(CBasicStatistics::mean(averageTime))};
-            TDouble1Vec prediction{m_Trend->mean(time)};
-            multiplier = controller.multiplier(prediction, errors[E_TrendControl],
+            TDouble1Vec trendMean{m_Trend->meanValue(time)};
+            multiplier = controller.multiplier(trendMean, errors[E_TrendControl],
                                                this->params().bucketLength(),
                                                this->params().learnRate(),
                                                this->params().decayRate());
@@ -777,8 +777,8 @@ CUnivariateTimeSeriesModel::addSamples(const CModelAddSamplesParams &params,
         }
         {
             CDecayRateController &controller{(*m_Controllers)[E_PriorControl]};
-            TDouble1Vec prediction{m_Prior->marginalLikelihoodMean()};
-            multiplier = controller.multiplier(prediction, errors[E_PriorControl],
+            TDouble1Vec residualMean{m_Prior->marginalLikelihoodMean()};
+            multiplier = controller.multiplier(residualMean, errors[E_PriorControl],
                                                this->params().bucketLength(),
                                                this->params().learnRate(),
                                                this->params().decayRate());
@@ -820,7 +820,7 @@ CUnivariateTimeSeriesModel::mode(core_t::TTime time,
         weights.push_back(weight[0]);
     }
     return {  m_Prior->marginalLikelihoodMode(weightStyles, weights)
-            + CBasicStatistics::mean(m_Trend->baseline(time))};
+            + CBasicStatistics::mean(m_Trend->value(time))};
 }
 
 CUnivariateTimeSeriesModel::TDouble2Vec1Vec
@@ -840,11 +840,11 @@ CUnivariateTimeSeriesModel::correlateModes(core_t::TTime time,
     {
         result.resize(correlated.size(), TDouble10Vec(2));
 
-        double baseline[2];
-        baseline[0] = CBasicStatistics::mean(m_Trend->baseline(time));
+        double trend[2];
+        trend[0] = CBasicStatistics::mean(m_Trend->value(time));
         for (std::size_t i = 0u; i < correlated.size(); ++i)
         {
-            baseline[1] = CBasicStatistics::mean(correlatedTimeSeriesModels[i]->m_Trend->baseline(time));
+            trend[1] = CBasicStatistics::mean(correlatedTimeSeriesModels[i]->m_Trend->value(time));
             TDouble10Vec4Vec weights;
             weights.resize(weights_[i].size(), TDouble10Vec(2));
             for (std::size_t j = 0u; j < weights_[i].size(); ++j)
@@ -855,8 +855,8 @@ CUnivariateTimeSeriesModel::correlateModes(core_t::TTime time,
                 }
             }
             TDouble10Vec mode(correlationDistributionModels[i].first->marginalLikelihoodMode(weightStyles, weights));
-            result[i][variables[i][0]] = baseline[0] + mode[variables[i][0]];
-            result[i][variables[i][1]] = baseline[1] + mode[variables[i][1]];
+            result[i][variables[i][0]] = trend[0] + mode[variables[i][0]];
+            result[i][variables[i][1]] = trend[1] + mode[variables[i][1]];
         }
     }
 
@@ -953,10 +953,10 @@ CUnivariateTimeSeriesModel::predict(core_t::TTime time,
 
     double scale{1.0 - this->params().probabilityBucketEmpty()};
 
-    double seasonalOffset{0.0};
+    double trend{0.0};
     if (m_Trend->initialized())
     {
-        seasonalOffset = CBasicStatistics::mean(m_Trend->baseline(time));
+        trend = CBasicStatistics::mean(m_Trend->value(time));
     }
 
     if (hint.size() == 1)
@@ -968,7 +968,7 @@ CUnivariateTimeSeriesModel::predict(core_t::TTime time,
                   m_Prior->marginalLikelihoodMean() :
                   (hint.empty() ? CBasicStatistics::mean(m_Prior->marginalLikelihoodConfidenceInterval(0.0)) :
                                   m_Prior->nearestMarginalLikelihoodMean(hint[0]))};
-    double result{scale * (seasonalOffset + median + correlateCorrection)};
+    double result{scale * (trend + median + correlateCorrection)};
 
     return {m_IsNonNegative ? std::max(result, 0.0) : result};
 }
@@ -986,8 +986,8 @@ CUnivariateTimeSeriesModel::confidenceInterval(core_t::TTime time,
 
     double scale{1.0 - this->params().probabilityBucketEmpty()};
 
-    double seasonalOffset{m_Trend->initialized() ?
-                          CBasicStatistics::mean(m_Trend->baseline(time, confidenceInterval)) : 0.0};
+    double trend{m_Trend->initialized() ?
+                 CBasicStatistics::mean(m_Trend->value(time, confidenceInterval)) : 0.0};
 
     TDouble4Vec weights;
     weights.reserve(weights_.size());
@@ -1001,9 +1001,9 @@ CUnivariateTimeSeriesModel::confidenceInterval(core_t::TTime time,
     TDoubleDoublePr interval{
             m_Prior->marginalLikelihoodConfidenceInterval(confidenceInterval, weightStyles, weights)};
 
-    double result[]{scale * (seasonalOffset + interval.first),
-                    scale * (seasonalOffset + median),
-                    scale * (seasonalOffset + interval.second)};
+    double result[]{scale * (trend + interval.first),
+                    scale * (trend + median),
+                    scale * (trend + interval.second)};
 
     return {{m_IsNonNegative ? std::max(result[0], 0.0) : result[0]},
             {m_IsNonNegative ? std::max(result[1], 0.0) : result[1]},
@@ -2208,13 +2208,13 @@ CMultivariateTimeSeriesModel::addSamples(const CModelAddSamplesParams &params,
         }
         {
             CDecayRateController &controller{(*m_Controllers)[E_TrendControl]};
-            TDouble1Vec prediction(dimension);
+            TDouble1Vec trendMean(dimension);
             core_t::TTime time{static_cast<core_t::TTime>(CBasicStatistics::mean(averageTime))};
             for (std::size_t d = 0u; d < dimension; ++d)
             {
-                prediction[d] = m_Trend[d]->mean(time);
+                trendMean[d] = m_Trend[d]->meanValue(time);
             }
-            double multiplier{controller.multiplier(prediction, errors[E_TrendControl],
+            double multiplier{controller.multiplier(trendMean, errors[E_TrendControl],
                                                     this->params().bucketLength(),
                                                     this->params().learnRate(),
                                                     this->params().decayRate())};
@@ -2229,8 +2229,8 @@ CMultivariateTimeSeriesModel::addSamples(const CModelAddSamplesParams &params,
         }
         {
             CDecayRateController &controller{(*m_Controllers)[E_PriorControl]};
-            TDouble1Vec prediction(m_Prior->marginalLikelihoodMean());
-            double multiplier{controller.multiplier(prediction, errors[E_PriorControl],
+            TDouble1Vec residualMean(m_Prior->marginalLikelihoodMean());
+            double multiplier{controller.multiplier(residualMean, errors[E_PriorControl],
                                                     this->params().bucketLength(),
                                                     this->params().learnRate(),
                                                     this->params().decayRate())};
@@ -2280,7 +2280,7 @@ CMultivariateTimeSeriesModel::mode(core_t::TTime time,
 
     for (std::size_t d = 0u; d < dimension; ++d)
     {
-        result[d] = mode[d] + CBasicStatistics::mean(m_Trend[d]->baseline(time));
+        result[d] = mode[d] + CBasicStatistics::mean(m_Trend[d]->value(time));
     }
 
     return result;
@@ -2353,10 +2353,10 @@ CMultivariateTimeSeriesModel::predict(core_t::TTime time,
     TDouble10Vec mean(m_Prior->marginalLikelihoodMean());
     for (std::size_t d = 0u; d < dimension; --marginalize[std::min(d, dimension - 2)], ++d)
     {
-        double seasonalOffset{0.0};
+        double trend{0.0};
         if (m_Trend[d]->initialized())
         {
-            seasonalOffset = CBasicStatistics::mean(m_Trend[d]->baseline(time));
+            trend = CBasicStatistics::mean(m_Trend[d]->value(time));
         }
         double median{mean[d]};
         if (!m_Prior->isNonInformative())
@@ -2365,7 +2365,7 @@ CMultivariateTimeSeriesModel::predict(core_t::TTime time,
             median = hint.empty() ? CBasicStatistics::mean(marginal->marginalLikelihoodConfidenceInterval(0.0)) :
                                     marginal->nearestMarginalLikelihoodMean(hint[d]);
         }
-        result[d] = scale * (seasonalOffset + median);
+        result[d] = scale * (trend + median);
         if (m_IsNonNegative)
         {
             result[d] = std::max(result[d], 0.0);
@@ -2401,9 +2401,8 @@ CMultivariateTimeSeriesModel::confidenceInterval(core_t::TTime time,
     TDouble4Vec weights;
     for (std::size_t d = 0u; d < dimension; --marginalize[std::min(d, dimension - 2)], ++d)
     {
-        double seasonalOffset{m_Trend[d]->initialized() ?
-                              CBasicStatistics::mean(
-                                      m_Trend[d]->baseline(time, confidenceInterval)) : 0.0};
+        double trend{m_Trend[d]->initialized() ?
+                     CBasicStatistics::mean(m_Trend[d]->value(time, confidenceInterval)) : 0.0};
 
         weights.clear();
         weights.reserve(weights_.size());
@@ -2417,9 +2416,9 @@ CMultivariateTimeSeriesModel::confidenceInterval(core_t::TTime time,
         TDoubleDoublePr interval{
                 marginal->marginalLikelihoodConfidenceInterval(confidenceInterval, weightStyles, weights)};
 
-        result[0][d] = scale * (seasonalOffset + interval.first);
-        result[1][d] = scale * (seasonalOffset + median);
-        result[2][d] = scale * (seasonalOffset + interval.second);
+        result[0][d] = scale * (trend + interval.first);
+        result[1][d] = scale * (trend + median);
+        result[2][d] = scale * (trend + interval.second);
         if (m_IsNonNegative)
         {
             result[0][d] = std::max(result[0][d], 0.0);