#3151 Resampling. Use 0 value outside the defined time range, for weighted mean calcs. Update unit tests

ApplicationCode/Application/Tools/RiaQDateTimeTools.cpp

@@ -154,6 +154,17 @@ QDateTime RiaQDateTimeTools::addSpan(const QDateTime& dt, DateTimeSpan span)
         .addDays(span.days());
 }
 
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+QDateTime RiaQDateTimeTools::subtractSpan(const QDateTime& dt, DateTimeSpan span)
+{
+    return createUtcDateTime(dt)
+        .addYears(-span.years())
+        .addMonths(-span.months())
+        .addDays(-span.days());
+}
+
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
@@ -162,6 +173,14 @@ QDateTime RiaQDateTimeTools::addPeriod(const QDateTime& dt, DateTimePeriod perio
     return addSpan(dt, timeSpan(period));
 }
 
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+QDateTime RiaQDateTimeTools::subtractPeriod(const QDateTime& dt, DateTimePeriod period)
+{
+    return subtractSpan(dt, timeSpan(period));
+}
+
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/Application/Tools/RiaQDateTimeTools.h

@@ -78,7 +78,9 @@ public:
     static QDateTime addDays(const QDateTime& dt, double days);
     static QDateTime addYears(const QDateTime& dt, double years);
     static QDateTime addSpan(const QDateTime& dt, DateTimeSpan span);
+    static QDateTime subtractSpan(const QDateTime& dt, DateTimeSpan span);
     static QDateTime addPeriod(const QDateTime& dt, DateTimePeriod period);
+    static QDateTime subtractPeriod(const QDateTime& dt, DateTimePeriod period);
 
     static QDateTime epoch();
 

ApplicationCode/Application/Tools/RiaTimeHistoryCurveResampler.cpp

@@ -98,11 +98,13 @@ std::vector<time_t> RiaTimeHistoryCurveResampler::timeStepsFromTimeRange(DateTim
     auto currTimeStep = firstResampledTimeStep(firstOriginalTimeStep, period);
 
     std::vector<time_t> timeSteps;
-    while (QDT::lessThanOrEqualTo(currTimeStep, lastOriginalTimeStep))
+    while (QDT::lessThan(currTimeStep, lastOriginalTimeStep))
     {
         timeSteps.push_back(currTimeStep.toTime_t());
         currTimeStep = QDT::addPeriod(currTimeStep, period);
     }
+    timeSteps.push_back(currTimeStep.toTime_t());
+
     return timeSteps;
 }
 
@@ -122,33 +124,47 @@ void RiaTimeHistoryCurveResampler::computeWeightedMeanValues(DateTimePeriod peri
     for (size_t i = 0; i < m_timeSteps.size(); i++)
     {
         double wMean = 0.0;
-        time_t periodStart = i > 0 ? m_timeSteps[i - 1] : origTimeSteps[0];
+        time_t periodStart = i > 0 ? m_timeSteps[i - 1] :
+            QDT::subtractPeriod(QDT::fromTime_t(m_timeSteps[0]), period).toTime_t();
         time_t periodEnd = m_timeSteps[i];
         time_t periodLength = periodEnd - periodStart;
 
         while(true)
         {
-            if (oi == origDataSize) break;
+            time_t origTimeStep = 0;
+            double origValue = 0.0;
+
+            if (oi > origDataSize) break;
+
+            if (oi < origDataSize)
+            {
+                origTimeStep = origTimeSteps[oi];
+                origValue = origValues[oi];
+            }
+            else
+            {
+                origTimeStep = periodEnd;
+                origValue = 0.0;
+            }
             
             if (oi == 0)
             {
-                if (origTimeSteps[oi] == m_timeSteps[i])
+                if (origTimeStep == m_timeSteps[i])
                 {
-                    wMean += origValues[0];
+                    wMean += origValue;
                     oi++;
                     break;
                 }
-                oi++;
+                origValue = 0.0;
-                continue;
             }
 
-            time_t startTime = std::max(origTimeSteps[oi-1], periodStart);
+            time_t startTime = oi > 0 ? std::max(origTimeSteps[oi - 1], periodStart) : periodStart;
-            time_t endTime = std::min(origTimeSteps[oi], periodEnd);
+            time_t endTime = std::min(origTimeStep, periodEnd);
             
-            wMean += origValues[oi] * (endTime - startTime) / periodLength;
+            wMean += origValue * (endTime - startTime) / periodLength;
 
-            if (origTimeSteps[oi] > m_timeSteps[i]) break;
+            if (origTimeStep > m_timeSteps[i]) break;
-            if (origTimeSteps[oi] == m_timeSteps[i])
+            if (origTimeStep == m_timeSteps[i])
             {
                 oi++;
                 break;
@@ -177,14 +193,17 @@ void RiaTimeHistoryCurveResampler::computePeriodEndValues(DateTimePeriod period)
     {
         while (oi < origDataSize && origTimeSteps[oi] < m_timeSteps[i]) oi++;
 
+        time_t origTimeStep = oi < origDataSize ? origTimeSteps[oi] : m_timeSteps[i];
+        double origValue = oi < origDataSize ? origValues[oi] : origValues[oi - 1];
+        
         double value;
-        if (oi > 0)
+        if (oi > 0 && origTimeStep >= m_timeSteps[i])
         {
-            value = interpolatedValue(m_timeSteps[i], origTimeSteps[oi - 1], origValues[oi - 1], origTimeSteps[oi], origValues[oi]);
+            value = interpolatedValue(m_timeSteps[i], origTimeSteps[oi - 1], origValues[oi - 1], origTimeStep, origValue);
         }
         else
         {
-            value = origValues[0];
+            value = origValue;
         }
 
         m_values.push_back(value);
@@ -213,11 +232,14 @@ void RiaTimeHistoryCurveResampler::computeResampledTimeSteps(DateTimePeriod peri
     clearData();
     auto currTimeStep = firstResampledTimeStep(firstOriginalTimeStep, period);
 
-    while (QDT::lessThanOrEqualTo(currTimeStep, lastOriginalTimeStep))
+    while (QDT::lessThan(currTimeStep, lastOriginalTimeStep))
     {
         m_timeSteps.push_back(currTimeStep.toTime_t());
         currTimeStep = QDT::addPeriod(currTimeStep, period);
     }
+
+    // Add last time step
+    m_timeSteps.push_back(currTimeStep.toTime_t());
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/UnitTests/RiaTimeHistoryCurveTools-Test.cpp

@@ -4,6 +4,11 @@
 #include "RiaQDateTimeTools.h"
 
 
+//--------------------------------------------------------------------------------------------------
+/// Constants
+//--------------------------------------------------------------------------------------------------
+static int SECS_PER_DAY = 60 * 60 * 24;
+
 //--------------------------------------------------------------------------------------------------
 /// Helpers
 //--------------------------------------------------------------------------------------------------
@@ -43,7 +48,8 @@ TEST(RiaTimeHistoryCurveResampler, Test_Resampling_NoPeriod)
     resampler.setCurveData(dataValues, toTime_tVector(timeStrings));
     resampler.resampleAndComputeWeightedMeanValues(DateTimePeriod::MONTH);
 
-    EXPECT_EQ(0, (int)resampler.resampledTimeSteps().size());
+    EXPECT_EQ(1, (int)resampler.resampledTimeSteps().size());
+    EXPECT_EQ(toTime_t("2018-03-01"), resampler.resampledTimeSteps()[0]);
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -71,10 +77,11 @@ TEST(RiaTimeHistoryCurveResampler, Test_Resampling_Decade)
     resampler.setCurveData(dataValues, toTime_tVector(timeStrings));
     resampler.resampleAndComputeWeightedMeanValues(DateTimePeriod::DECADE);
 
-    EXPECT_EQ(3, (int)resampler.resampledTimeSteps().size());
+    EXPECT_EQ(4, (int)resampler.resampledTimeSteps().size());
     EXPECT_EQ(toTime_t("1990-01-01"), resampler.resampledTimeSteps()[0]);
     EXPECT_EQ(toTime_t("2000-01-01"), resampler.resampledTimeSteps()[1]);
     EXPECT_EQ(toTime_t("2010-01-01"), resampler.resampledTimeSteps()[2]);
+    EXPECT_EQ(toTime_t("2020-01-01"), resampler.resampledTimeSteps()[3]);
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -102,11 +109,12 @@ TEST(RiaTimeHistoryCurveResampler, Test_Resampling_Year)
     resampler.setCurveData(dataValues, toTime_tVector(timeStrings));
     resampler.resampleAndComputeWeightedMeanValues(DateTimePeriod::YEAR);
 
-    EXPECT_EQ(4, (int)resampler.resampledTimeSteps().size());
+    EXPECT_EQ(5, (int)resampler.resampledTimeSteps().size());
     EXPECT_EQ(toTime_t("2015-01-01"), resampler.resampledTimeSteps()[0]);
     EXPECT_EQ(toTime_t("2016-01-01"), resampler.resampledTimeSteps()[1]);
     EXPECT_EQ(toTime_t("2017-01-01"), resampler.resampledTimeSteps()[2]);
     EXPECT_EQ(toTime_t("2018-01-01"), resampler.resampledTimeSteps()[3]);
+    EXPECT_EQ(toTime_t("2019-01-01"), resampler.resampledTimeSteps()[4]);
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -134,11 +142,12 @@ TEST(RiaTimeHistoryCurveResampler, Test_Resampling_HalfYear)
     resampler.setCurveData(dataValues, toTime_tVector(timeStrings));
     resampler.resampleAndComputeWeightedMeanValues(DateTimePeriod::HALFYEAR);
 
-    EXPECT_EQ(4, (int)resampler.resampledTimeSteps().size());
+    EXPECT_EQ(5, (int)resampler.resampledTimeSteps().size());
     EXPECT_EQ(toTime_t("2016-07-01"), resampler.resampledTimeSteps()[0]);
     EXPECT_EQ(toTime_t("2017-01-01"), resampler.resampledTimeSteps()[1]);
     EXPECT_EQ(toTime_t("2017-07-01"), resampler.resampledTimeSteps()[2]);
     EXPECT_EQ(toTime_t("2018-01-01"), resampler.resampledTimeSteps()[3]);
+    EXPECT_EQ(toTime_t("2018-07-01"), resampler.resampledTimeSteps()[4]);
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -166,13 +175,14 @@ TEST(RiaTimeHistoryCurveResampler, Test_Resampling_Quarter)
     resampler.setCurveData(dataValues, toTime_tVector(timeStrings));
     resampler.resampleAndComputeWeightedMeanValues(DateTimePeriod::QUARTER);
 
-    EXPECT_EQ(6, (int)resampler.resampledTimeSteps().size());
+    EXPECT_EQ(7, (int)resampler.resampledTimeSteps().size());
     EXPECT_EQ(toTime_t("2016-10-01"), resampler.resampledTimeSteps()[0]);
     EXPECT_EQ(toTime_t("2017-01-01"), resampler.resampledTimeSteps()[1]);
     EXPECT_EQ(toTime_t("2017-04-01"), resampler.resampledTimeSteps()[2]);
     EXPECT_EQ(toTime_t("2017-07-01"), resampler.resampledTimeSteps()[3]);
     EXPECT_EQ(toTime_t("2017-10-01"), resampler.resampledTimeSteps()[4]);
     EXPECT_EQ(toTime_t("2018-01-01"), resampler.resampledTimeSteps()[5]);
+    EXPECT_EQ(toTime_t("2018-04-01"), resampler.resampledTimeSteps()[6]);
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -200,12 +210,13 @@ TEST(RiaTimeHistoryCurveResampler, Test_Resampling_Month)
     resampler.setCurveData(dataValues, toTime_tVector(timeStrings));
     resampler.resampleAndComputeWeightedMeanValues(DateTimePeriod::MONTH);
 
-    EXPECT_EQ(5, (int)resampler.resampledTimeSteps().size());
+    EXPECT_EQ(6, (int)resampler.resampledTimeSteps().size());
     EXPECT_EQ(toTime_t("2017-10-01"), resampler.resampledTimeSteps()[0]);
     EXPECT_EQ(toTime_t("2017-11-01"), resampler.resampledTimeSteps()[1]);
     EXPECT_EQ(toTime_t("2017-12-01"), resampler.resampledTimeSteps()[2]);
     EXPECT_EQ(toTime_t("2018-01-01"), resampler.resampledTimeSteps()[3]);
     EXPECT_EQ(toTime_t("2018-02-01"), resampler.resampledTimeSteps()[4]);
+    EXPECT_EQ(toTime_t("2018-03-01"), resampler.resampledTimeSteps()[5]);
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -233,7 +244,7 @@ TEST(RiaTimeHistoryCurveResampler, Test_Resampling_Week)
     resampler.setCurveData(dataValues, toTime_tVector(timeStrings));
     resampler.resampleAndComputeWeightedMeanValues(DateTimePeriod::WEEK);
 
-    EXPECT_EQ(9, (int)resampler.resampledTimeSteps().size());
+    EXPECT_EQ(10, (int)resampler.resampledTimeSteps().size());
     EXPECT_EQ(toTime_t("2017-11-06"), resampler.resampledTimeSteps()[0]);
     EXPECT_EQ(toTime_t("2017-11-13"), resampler.resampledTimeSteps()[1]);
     EXPECT_EQ(toTime_t("2017-11-20"), resampler.resampledTimeSteps()[2]);
@@ -243,6 +254,7 @@ TEST(RiaTimeHistoryCurveResampler, Test_Resampling_Week)
     EXPECT_EQ(toTime_t("2017-12-18"), resampler.resampledTimeSteps()[6]);
     EXPECT_EQ(toTime_t("2017-12-25"), resampler.resampledTimeSteps()[7]);
     EXPECT_EQ(toTime_t("2018-01-01"), resampler.resampledTimeSteps()[8]);
+    EXPECT_EQ(toTime_t("2018-01-08"), resampler.resampledTimeSteps()[9]);
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -270,7 +282,36 @@ TEST(RiaTimeHistoryCurveResampler, Test_Resampling_NoSampleCrossingPeriodBoundar
     resampler.setCurveData(dataValues, toTime_tVector(timeStrings));
     resampler.resampleAndComputeWeightedMeanValues(DateTimePeriod::YEAR);
 
-    EXPECT_EQ(0, (int)resampler.resampledTimeSteps().size());
+    EXPECT_EQ(1, (int)resampler.resampledTimeSteps().size());
+    EXPECT_EQ(toTime_t("2018-01-01"), resampler.resampledTimeSteps()[0]);
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+TEST(RiaTimeHistoryCurveResampler, Test_WeightedMean_SingleSample)
+{
+    std::vector<QString> timeStrings(
+        {
+            "2018-02-07"
+        }
+    );
+
+    std::vector<double> dataValues(
+        {
+            3.0
+        }
+    );
+
+    RiaTimeHistoryCurveResampler resampler;
+    resampler.setCurveData(dataValues, toTime_tVector(timeStrings));
+    resampler.resampleAndComputeWeightedMeanValues(DateTimePeriod::MONTH);
+
+    EXPECT_EQ(1, (int)resampler.resampledTimeSteps().size());
+    EXPECT_EQ(toTime_t("2018-03-01"), resampler.resampledTimeSteps()[0]);
+
+    double value = 0.0;
+    EXPECT_NEAR(value, resampler.resampledValues()[0], 1e-12);
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -331,25 +372,29 @@ TEST(RiaTimeHistoryCurveResampler, Test_WeightedMean_Decade)
         }
     );
 
+    time_t t0 = toTime_t("1999-02-03");
+    time_t t1 = toTime_t("2005-06-06");
+    time_t t2 = toTime_t("2012-02-07");
+    time_t tp0 = toTime_t("2000-01-01");
+    time_t tp1 = toTime_t("2010-01-01");
+    time_t tp2 = toTime_t("2020-01-01");
+
     RiaTimeHistoryCurveResampler resampler;
     resampler.setCurveData(dataValues, toTime_tVector(timeStrings));
     resampler.resampleAndComputeWeightedMeanValues(DateTimePeriod::DECADE);
 
-    EXPECT_EQ(2, (int)resampler.resampledTimeSteps().size());
+    EXPECT_EQ(3, (int)resampler.resampledTimeSteps().size());
-    EXPECT_EQ(toTime_t("2000-01-01"), resampler.resampledTimeSteps()[0]);
+    EXPECT_EQ(tp0, resampler.resampledTimeSteps()[0]);
-    EXPECT_EQ(toTime_t("2010-01-01"), resampler.resampledTimeSteps()[1]);
+    EXPECT_EQ(tp1, resampler.resampledTimeSteps()[1]);
+    EXPECT_EQ(tp2, resampler.resampledTimeSteps()[2]);
 
-    time_t t1 = toTime_t("1999-02-03");
+    double value0 = 5.0 * (tp0 - t0) / (tp0 - toTime_t("1990-01-01"));
-    time_t t2 = toTime_t("2005-06-06");
+    double value1 = (5.0 * (t1 - tp0) + 7.0 * (tp1 - t1)) / (tp1 - tp0);
-    time_t t3 = toTime_t("2012-02-07");
+    double value2 = 7.0 * (t2 - tp1) / (tp2 - tp1);
-    time_t tp1 = toTime_t("2000-01-01");
-    time_t tp2 = toTime_t("2010-01-01");
 
-    double value1 = 5.0;
+    EXPECT_NEAR(value0, resampler.resampledValues()[0], 1e-12);
-    double value2 = (5.0 * (t2 - tp1) + 7.0 * (tp2 - t2)) / (tp2 - tp1);
+    EXPECT_NEAR(value1, resampler.resampledValues()[1], 1e-12);
-
+    EXPECT_NEAR(value2, resampler.resampledValues()[2], 1e-12);
-    EXPECT_NEAR(value1, resampler.resampledValues()[0], 1e-12);
-    EXPECT_NEAR(value2, resampler.resampledValues()[1], 1e-12);
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -377,29 +422,33 @@ TEST(RiaTimeHistoryCurveResampler, Test_WeightedMean_SamplesStartBeforePeriod)
         }
     );
     
+    time_t tp0 = toTime_t("2018-02-01");
+    time_t tp1 = toTime_t("2018-03-01");
+    time_t tp2 = toTime_t("2018-04-01");
+
     RiaTimeHistoryCurveResampler resampler;
     resampler.setCurveData(dataValues, toTime_tVector(timeStrings));
     resampler.resampleAndComputeWeightedMeanValues(DateTimePeriod::MONTH);
 
-    EXPECT_EQ(2, (int)resampler.resampledTimeSteps().size());
+    EXPECT_EQ(3, (int)resampler.resampledTimeSteps().size());
-    EXPECT_EQ(toTime_t("2018-02-01"), resampler.resampledTimeSteps().front());
+    EXPECT_EQ(tp0, resampler.resampledTimeSteps()[0]);
-    EXPECT_EQ(toTime_t("2018-03-01"), resampler.resampledTimeSteps().back());
+    EXPECT_EQ(tp1, resampler.resampledTimeSteps()[1]);
+    EXPECT_EQ(tp2, resampler.resampledTimeSteps()[2]);
 
-    time_t timePeriod1 = toTime_t("2018-02-01") - toTime_t("2018-01-20");
+    double value0 =
-    time_t timePeriod2 = toTime_t("2018-03-01") - toTime_t("2018-02-01");
+        (5.0 * 9 +
-    int timeDay = 60 * 60 * 24;
+         7.0 * 3) * SECS_PER_DAY / (tp0 - toTime_t("2018-01-01"));
 
     double value1 =
-        (5.0 * 9 +
-         7.0 * 3) * timeDay / timePeriod1;
-
-    double value2 =
         (7.0 * 2 +
          11.0 * 24 +
-         13.0 * 2) * timeDay / timePeriod2;
+         13.0 * 2) * SECS_PER_DAY / (tp1 - tp0);
 
-    EXPECT_NEAR(value1, resampler.resampledValues()[0], 1e-12);
+    double value2 = 13.0 * 1 * SECS_PER_DAY / (tp2 - tp1);
-    EXPECT_NEAR(value2, resampler.resampledValues()[1], 1e-12);
+
+    EXPECT_NEAR(value0, resampler.resampledValues()[0], 1e-12);
+    EXPECT_NEAR(value1, resampler.resampledValues()[1], 1e-12);
+    EXPECT_NEAR(value2, resampler.resampledValues()[2], 1e-12);
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -427,27 +476,31 @@ TEST(RiaTimeHistoryCurveResampler, Test_WeightedMean_SamplesStartBeforePeriod_Ti
         }
     );
 
+    time_t tp0 = toTime_t("2018-02-01");
+    time_t tp1 = toTime_t("2018-03-01");
+    time_t tp2 = toTime_t("2018-04-01");
+
     RiaTimeHistoryCurveResampler resampler;
     resampler.setCurveData(dataValues, toTime_tVector(timeStrings));
     resampler.resampleAndComputeWeightedMeanValues(DateTimePeriod::MONTH);
 
-    EXPECT_EQ(2, (int)resampler.resampledTimeSteps().size());
+    EXPECT_EQ(3, (int)resampler.resampledTimeSteps().size());
-    EXPECT_EQ(toTime_t("2018-02-01"), resampler.resampledTimeSteps().front());
+    EXPECT_EQ(tp0, resampler.resampledTimeSteps()[0]);
-    EXPECT_EQ(toTime_t("2018-03-01"), resampler.resampledTimeSteps().back());
+    EXPECT_EQ(tp1, resampler.resampledTimeSteps()[1]);
+    EXPECT_EQ(tp2, resampler.resampledTimeSteps()[2]);
 
-    time_t timePeriod1 = toTime_t("2018-02-01") - toTime_t("2018-01-20");
+    double value0 =
-    time_t timePeriod2 = toTime_t("2018-03-01") - toTime_t("2018-02-01");
+        (5.0 * 12) * SECS_PER_DAY / (tp0 - toTime_t("2018-01-01"));
-    int timeDay = 60 * 60 * 24;
 
     double value1 =
-        (5.0 * 12) * timeDay / timePeriod1;
-
-    double value2 =
         (7.0 * 2 +
-         11.0 * 26) * timeDay / timePeriod2;
+         11.0 * 26) * SECS_PER_DAY / (tp1 - tp0);
 
-    EXPECT_NEAR(value1, resampler.resampledValues()[0], 1e-12);
+    double value2 = 13.0 * 1 * SECS_PER_DAY / (tp2 - tp1);
-    EXPECT_NEAR(value2, resampler.resampledValues()[1], 1e-12);
+
+    EXPECT_NEAR(value0, resampler.resampledValues()[0], 1e-12);
+    EXPECT_NEAR(value1, resampler.resampledValues()[1], 1e-12);
+    EXPECT_NEAR(value2, resampler.resampledValues()[2], 1e-12);
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -480,12 +533,11 @@ TEST(RiaTimeHistoryCurveResampler, Test_WeightedMean_SamplesStartAndEndMatchPeri
     EXPECT_EQ(toTime_t("2018-03-01"), resampler.resampledTimeSteps().back());
 
     time_t timePeriod = toTime_t("2018-03-01") - toTime_t("2018-02-01");
-    int timeDay = 60 * 60 * 24;
 
     double value1 = 3.0;
     double value2 =
         (5.0 * 9 +
-         7.0 * 19) * timeDay / timePeriod;
+         7.0 * 19) * SECS_PER_DAY / timePeriod;
 
     EXPECT_NEAR(value1, resampler.resampledValues()[0], 1e-12);
     EXPECT_NEAR(value2, resampler.resampledValues()[1], 1e-12);
@@ -514,24 +566,100 @@ TEST(RiaTimeHistoryCurveResampler, Test_WeightedMean_SamplesStartMatchPeriodStar
         }
     );
 
+    time_t tp0 = toTime_t("2018-02-01");
+    time_t tp1 = toTime_t("2018-03-01");
+    time_t tp2 = toTime_t("2018-04-01");
+
+    RiaTimeHistoryCurveResampler resampler;
+    resampler.setCurveData(dataValues, toTime_tVector(timeStrings));
+    resampler.resampleAndComputeWeightedMeanValues(DateTimePeriod::MONTH);
+
+    EXPECT_EQ(3, (int)resampler.resampledTimeSteps().size());
+    EXPECT_EQ(tp0, resampler.resampledTimeSteps()[0]);
+    EXPECT_EQ(tp1, resampler.resampledTimeSteps()[1]);
+    EXPECT_EQ(tp2, resampler.resampledTimeSteps()[2]);
+
+    double value0 = 3.0;
+    double value1 =
+        (5.0 * 9 +
+         7.0 * 19) * SECS_PER_DAY / (tp1 - tp0);
+    double value2 = 11.0 * 1 * SECS_PER_DAY / (tp2 - tp1);
+
+    EXPECT_NEAR(value0, resampler.resampledValues()[0], 1e-12);
+    EXPECT_NEAR(value1, resampler.resampledValues()[1], 1e-12);
+    EXPECT_NEAR(value2, resampler.resampledValues()[2], 1e-12);
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+TEST(RiaTimeHistoryCurveResampler, Test_WeightedMean_MultipleSamplesInLastPeriod)
+{
+    std::vector<QString> timeStrings(
+        {
+            "2018-02-10",
+            "2018-03-02",
+            "2018-03-05",
+            "2018-03-15"
+        }
+    );
+
+    std::vector<double> dataValues(
+        {
+            3.0,
+            5.0,
+            7.0,
+            11.0
+        }
+    );
+
+    time_t tp0 = toTime_t("2018-03-01");
+    time_t tp1 = toTime_t("2018-04-01");
+
     RiaTimeHistoryCurveResampler resampler;
     resampler.setCurveData(dataValues, toTime_tVector(timeStrings));
     resampler.resampleAndComputeWeightedMeanValues(DateTimePeriod::MONTH);
 
     EXPECT_EQ(2, (int)resampler.resampledTimeSteps().size());
-    EXPECT_EQ(toTime_t("2018-02-01"), resampler.resampledTimeSteps().front());
+    EXPECT_EQ(tp0, resampler.resampledTimeSteps()[0]);
-    EXPECT_EQ(toTime_t("2018-03-01"), resampler.resampledTimeSteps().back());
+    EXPECT_EQ(tp1, resampler.resampledTimeSteps()[1]);
 
-    time_t timePeriod = toTime_t("2018-03-01") - toTime_t("2018-02-01");
+    double value0 = 5.0 * 19 * SECS_PER_DAY / (tp0 - toTime_t("2018-02-01"));
-    int timeDay = 60 * 60 * 24;
+    double value1 =
+        (0.0 * 17 +
+         11.0 * 10 +
+         7.0 * 3 +
+         5.0 * 1) * SECS_PER_DAY / (tp1 - tp0);
 
-    double value1 = 3.0;
+    EXPECT_NEAR(value0, resampler.resampledValues()[0], 1e-12);
-    double value2 =
+    EXPECT_NEAR(value1, resampler.resampledValues()[1], 1e-12);
-        (5.0 * 9 +
+}
-         7.0 * 19) * timeDay / timePeriod;
 
-    EXPECT_NEAR(value1, resampler.resampledValues()[0], 1e-12);
+//--------------------------------------------------------------------------------------------------
-    EXPECT_NEAR(value2, resampler.resampledValues()[1], 1e-12);
+/// 
+//--------------------------------------------------------------------------------------------------
+TEST(RiaTimeHistoryCurveResampler, Test_PeriodEndValues_SingleSample)
+{
+    std::vector<QString> timeStrings(
+        {
+            "2018-02-10"
+        }
+    );
+
+    std::vector<double> dataValues(
+        {
+            3.0
+        }
+    );
+
+    RiaTimeHistoryCurveResampler resampler;
+    resampler.setCurveData(dataValues, toTime_tVector(timeStrings));
+    resampler.resampleAndComputePeriodEndValues(DateTimePeriod::MONTH);
+
+    EXPECT_EQ(1, (int)resampler.resampledTimeSteps().size());
+    EXPECT_EQ(toTime_t("2018-03-01"), resampler.resampledTimeSteps()[0]);
+
+    EXPECT_NEAR(3.0, resampler.resampledValues()[0], 1e-12);
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -557,26 +685,30 @@ TEST(RiaTimeHistoryCurveResampler, Test_PeriodEndValues_SamplesStartBeforePeriod
         }
     );
 
+    time_t t0 = toTime_t("2018-01-30");
+    time_t t1 = toTime_t("2018-02-10");
+    time_t t2 = toTime_t("2018-03-05");
+    time_t t3 = toTime_t("2018-03-02");
+    time_t tp0 = toTime_t("2018-02-01");
+    time_t tp1 = toTime_t("2018-03-01");
+    time_t tp2 = toTime_t("2018-04-01");
+
     RiaTimeHistoryCurveResampler resampler;
     resampler.setCurveData(dataValues, toTime_tVector(timeStrings));
     resampler.resampleAndComputePeriodEndValues(DateTimePeriod::MONTH);
 
-    time_t t1 = toTime_t("2018-01-30");
+    EXPECT_EQ(3, (int)resampler.resampledTimeSteps().size());
-    time_t t2 = toTime_t("2018-02-10");
+    EXPECT_EQ(tp0, resampler.resampledTimeSteps()[0]);
-    time_t t3 = toTime_t("2018-03-05");
+    EXPECT_EQ(tp1, resampler.resampledTimeSteps()[1]);
-    time_t t4 = toTime_t("2018-03-02");
+    EXPECT_EQ(tp2, resampler.resampledTimeSteps()[2]);
-    time_t tp1 = toTime_t("2018-02-01");
-    time_t tp2 = toTime_t("2018-03-01");
 
-    EXPECT_EQ(2, (int)resampler.resampledTimeSteps().size());
+    double value0 = (5.0 - 3.0) * (tp0 - t0) / (t1 - t0) + 3.0;
-    EXPECT_EQ(toTime_t("2018-02-01"), resampler.resampledTimeSteps().front());
+    double value1 = (7.0 - 5.0) * (tp1 - t1) / (t2 - t1) + 5.0;
-    EXPECT_EQ(toTime_t("2018-03-01"), resampler.resampledTimeSteps().back());
+    double value2 = 11.0;
 
-    double value1 = (5.0 - 3.0) * (tp1 - t1) / (t2 - t1) + 3.0;
+    EXPECT_NEAR(value0, resampler.resampledValues()[0], 1e-12);
-    double value2 = (7.0 - 5.0) * (tp2 - t2) / (t3 - t2) + 5.0;
+    EXPECT_NEAR(value1, resampler.resampledValues()[1], 1e-12);
-
+    EXPECT_NEAR(value2, resampler.resampledValues()[2], 1e-12);
-    EXPECT_NEAR(value1, resampler.resampledValues()[0], 1e-12);
-    EXPECT_NEAR(value2, resampler.resampledValues()[1], 1e-12);
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -606,12 +738,14 @@ TEST(RiaTimeHistoryCurveResampler, Test_PeriodEndValues_SamplesStartMatchPeriod)
     resampler.setCurveData(dataValues, toTime_tVector(timeStrings));
     resampler.resampleAndComputePeriodEndValues(DateTimePeriod::MONTH);
 
-    EXPECT_EQ(2, (int)resampler.resampledTimeSteps().size());
+    EXPECT_EQ(3, (int)resampler.resampledTimeSteps().size());
-    EXPECT_EQ(toTime_t("2018-02-01"), resampler.resampledTimeSteps().front());
+    EXPECT_EQ(toTime_t("2018-02-01"), resampler.resampledTimeSteps()[0]);
-    EXPECT_EQ(toTime_t("2018-03-01"), resampler.resampledTimeSteps().back());
+    EXPECT_EQ(toTime_t("2018-03-01"), resampler.resampledTimeSteps()[1]);
+    EXPECT_EQ(toTime_t("2018-04-01"), resampler.resampledTimeSteps()[2]);
 
     EXPECT_NEAR(3.0, resampler.resampledValues()[0], 1e-12);
     EXPECT_NEAR(7.0, resampler.resampledValues()[1], 1e-12);
+    EXPECT_NEAR(11.0, resampler.resampledValues()[2], 1e-12);
 }
 
 //--------------------------------------------------------------------------------------------------