diff --git a/src/details/collection_function.cpp b/src/details/collection_function.cpp
index d92fdf3..360f082 100644
--- a/src/details/collection_function.cpp
+++ b/src/details/collection_function.cpp
@@ -8,101 +8,105 @@
 class FunctionSingle : public CollectionFunction
 {
   public:
-    ReadingItem calculate(const std::vector<ReadingItem>& readings,
-                          uint64_t) const override
+    double calculate(const std::vector<ReadingItem>& readings,
+                     Milliseconds) const override
     {
-        return readings.back();
+        return readings.back().second;
     }
 
-    ReadingItem calculateForStartupInterval(std::vector<ReadingItem>& readings,
-                                            uint64_t timestamp) const override
+    double calculateForStartupInterval(std::vector<ReadingItem>& readings,
+                                       Milliseconds) const override
     {
         readings.assign({readings.back()});
-        return readings.back();
+        return readings.back().second;
     }
 };
 
 class FunctionMinimum : public CollectionFunction
 {
   public:
-    ReadingItem calculate(const std::vector<ReadingItem>& readings,
-                          uint64_t) const override
+    double calculate(const std::vector<ReadingItem>& readings,
+                     Milliseconds) const override
     {
-        return *std::min_element(
-            readings.begin(), readings.end(),
-            [](const auto& left, const auto& right) {
-                return std::make_tuple(!std::isfinite(left.second),
-                                       left.second) <
-                       std::make_tuple(!std::isfinite(right.second),
-                                       right.second);
-            });
+        return std::min_element(
+                   readings.begin(), readings.end(),
+                   [](const auto& left, const auto& right) {
+                       return std::make_tuple(!std::isfinite(left.second),
+                                              left.second) <
+                              std::make_tuple(!std::isfinite(right.second),
+                                              right.second);
+                   })
+            ->second;
     }
 
-    ReadingItem calculateForStartupInterval(std::vector<ReadingItem>& readings,
-                                            uint64_t timestamp) const override
+    double calculateForStartupInterval(std::vector<ReadingItem>& readings,
+                                       Milliseconds timestamp) const override
     {
-        readings.assign({ReadingItem(calculate(readings, timestamp))});
-        return readings.back();
+        readings.assign(
+            {ReadingItem(timestamp, calculate(readings, timestamp))});
+        return readings.back().second;
     }
 };
 
 class FunctionMaximum : public CollectionFunction
 {
   public:
-    ReadingItem calculate(const std::vector<ReadingItem>& readings,
-                          uint64_t) const override
+    double calculate(const std::vector<ReadingItem>& readings,
+                     Milliseconds) const override
     {
-        return *std::max_element(
-            readings.begin(), readings.end(),
-            [](const auto& left, const auto& right) {
-                return std::make_tuple(std::isfinite(left.second),
-                                       left.second) <
-                       std::make_tuple(std::isfinite(right.second),
-                                       right.second);
-            });
+        return std::max_element(
+                   readings.begin(), readings.end(),
+                   [](const auto& left, const auto& right) {
+                       return std::make_tuple(std::isfinite(left.second),
+                                              left.second) <
+                              std::make_tuple(std::isfinite(right.second),
+                                              right.second);
+                   })
+            ->second;
     }
 
-    ReadingItem calculateForStartupInterval(std::vector<ReadingItem>& readings,
-                                            uint64_t timestamp) const override
+    double calculateForStartupInterval(std::vector<ReadingItem>& readings,
+                                       Milliseconds timestamp) const override
     {
-        readings.assign({ReadingItem(calculate(readings, timestamp))});
-        return readings.back();
+        readings.assign(
+            {ReadingItem(timestamp, calculate(readings, timestamp))});
+        return readings.back().second;
     }
 };
 
 class FunctionAverage : public CollectionFunction
 {
   public:
-    ReadingItem calculate(const std::vector<ReadingItem>& readings,
-                          uint64_t timestamp) const override
+    double calculate(const std::vector<ReadingItem>& readings,
+                     Milliseconds timestamp) const override
     {
         auto valueSum = 0.0;
-        auto timeSum = uint64_t{0};
+        auto timeSum = Milliseconds{0};
         for (auto it = readings.begin(); it != std::prev(readings.end()); ++it)
         {
             if (std::isfinite(it->second))
             {
                 const auto kt = std::next(it);
                 const auto duration = kt->first - it->first;
-                valueSum += it->second * duration;
+                valueSum += it->second * duration.count();
                 timeSum += duration;
             }
         }
 
         const auto duration = timestamp - readings.back().first;
-        valueSum += readings.back().second * duration;
+        valueSum += readings.back().second * duration.count();
         timeSum += duration;
 
-        return ReadingItem{timestamp, valueSum / timeSum};
+        return valueSum / std::max(timeSum.count(), uint64_t{1u});
     }
 
-    ReadingItem calculateForStartupInterval(std::vector<ReadingItem>& readings,
-                                            uint64_t timestamp) const override
+    double calculateForStartupInterval(std::vector<ReadingItem>& readings,
+                                       Milliseconds timestamp) const override
     {
         auto result = calculate(readings, timestamp);
-        if (std::isfinite(result.second))
+        if (std::isfinite(result))
         {
-            readings.assign({ReadingItem(readings.front().first, result.second),
+            readings.assign({ReadingItem(readings.front().first, result),
                              ReadingItem(timestamp, readings.back().second)});
         }
         return result;
@@ -111,9 +115,11 @@
 
 class FunctionSummation : public CollectionFunction
 {
+    using Multiplier = std::chrono::duration<double>;
+
   public:
-    ReadingItem calculate(const std::vector<ReadingItem>& readings,
-                          uint64_t timestamp) const override
+    double calculate(const std::vector<ReadingItem>& readings,
+                     const Milliseconds timestamp) const override
     {
         auto valueSum = 0.0;
         for (auto it = readings.begin(); it != std::prev(readings.end()); ++it)
@@ -121,28 +127,45 @@
             if (std::isfinite(it->second))
             {
                 const auto kt = std::next(it);
-                const auto duration = kt->first - it->first;
-                valueSum += it->second * duration;
+                const auto multiplier =
+                    calculateMultiplier(kt->first - it->first);
+                valueSum += it->second * multiplier.count();
             }
         }
 
-        const auto duration = timestamp - readings.back().first;
-        valueSum += readings.back().second * duration;
+        const auto multiplier =
+            calculateMultiplier(timestamp - readings.back().first);
+        valueSum += readings.back().second * multiplier.count();
 
-        return ReadingItem{timestamp, valueSum};
+        return valueSum;
     }
 
-    ReadingItem calculateForStartupInterval(std::vector<ReadingItem>& readings,
-                                            uint64_t timestamp) const override
+    double
+        calculateForStartupInterval(std::vector<ReadingItem>& readings,
+                                    const Milliseconds timestamp) const override
     {
-        auto result = calculate(readings, timestamp);
-        if (std::isfinite(result.second) && timestamp > 0u)
+        const auto result = calculate(readings, timestamp);
+        if (readings.size() > 2 && std::isfinite(result))
         {
-            readings.assign({ReadingItem(timestamp - 1u, result.second),
-                             ReadingItem(timestamp, readings.back().second)});
+            const auto multiplier =
+                calculateMultiplier(timestamp - readings.front().first).count();
+            if (multiplier > 0.)
+            {
+                const auto prevValue = result / multiplier;
+                readings.assign(
+                    {ReadingItem(readings.front().first, prevValue),
+                     ReadingItem(timestamp, readings.back().second)});
+            }
         }
         return result;
     }
+
+  private:
+    static constexpr Multiplier calculateMultiplier(Milliseconds duration)
+    {
+        constexpr auto m = Multiplier{Seconds{1}};
+        return Multiplier{duration / m};
+    }
 };
 
 std::shared_ptr<CollectionFunction>