@ladybugmem/icebug 0.1.0

package/vendor/include/tlx/logger/tuple.hpp

@@ -0,0 +1,66 @@
+/*******************************************************************************
+ * tlx/logger/tuple.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2018 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_LOGGER_TUPLE_HEADER
+#define TLX_LOGGER_TUPLE_HEADER
+
+#include <tlx/logger/core.hpp>
+#include <tlx/meta/call_foreach_tuple_with_index.hpp>
+#include <ostream>
+#include <tuple>
+#include <type_traits>
+
+namespace tlx {
+
+class LoggerTupleFormatter
+{
+public:
+    explicit LoggerTupleFormatter(std::ostream& os) : os_(os)
+    {
+    }
+
+    template <typename Index, typename Arg>
+    void operator()(const Index&, const Arg& a) const
+    {
+        if (Index::index != 0)
+            os_ << ',';
+        LoggerFormatter<typename std::decay<Arg>::type>::print(os_, a);
+    }
+
+    std::ostream& os_;
+};
+
+template <typename... Args>
+class LoggerFormatter<std::tuple<Args...> >
+{
+public:
+    static void print(std::ostream& os, const std::tuple<Args...>& t)
+    {
+        os << '(';
+        call_foreach_tuple_with_index(LoggerTupleFormatter(os), t);
+        os << ')';
+    }
+};
+
+template <>
+class LoggerFormatter<std::tuple<> >
+{
+public:
+    static void print(std::ostream& os, const std::tuple<>&)
+    {
+        os << '(' << ')';
+    }
+};
+
+} // namespace tlx
+
+#endif // !TLX_LOGGER_TUPLE_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/logger/unordered_map.hpp

@@ -0,0 +1,68 @@
+/*******************************************************************************
+ * tlx/logger/unordered_map.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2018 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_LOGGER_UNORDERED_MAP_HEADER
+#define TLX_LOGGER_UNORDERED_MAP_HEADER
+
+#include <tlx/logger/core.hpp>
+#include <ostream>
+#include <unordered_map>
+
+namespace tlx {
+
+template <typename K, typename V, typename H, typename E, typename A>
+class LoggerFormatter<std::unordered_map<K, V, H, E, A> >
+{
+public:
+    static void print(std::ostream& os,
+                      const std::unordered_map<K, V, H, E, A>& data)
+    {
+        os << '{';
+        for (typename std::unordered_map<K, V, H, E, A>::const_iterator it =
+                 data.begin();
+             it != data.end(); ++it)
+        {
+            if (it != data.begin())
+                os << ',';
+            LoggerFormatter<K>::print(os, it->first);
+            os << '=';
+            LoggerFormatter<V>::print(os, it->second);
+        }
+        os << '}';
+    }
+};
+
+template <typename K, typename V, typename H, typename E, typename A>
+class LoggerFormatter<std::unordered_multimap<K, V, H, E, A> >
+{
+public:
+    static void print(std::ostream& os,
+                      const std::unordered_multimap<K, V, H, E, A>& data)
+    {
+        os << '{';
+        for (typename std::unordered_multimap<K, V, H, E, A>::const_iterator
+                 it = data.begin();
+             it != data.end(); ++it)
+        {
+            if (it != data.begin())
+                os << ',';
+            LoggerFormatter<K>::print(os, it->first);
+            os << '=';
+            LoggerFormatter<V>::print(os, it->second);
+        }
+        os << '}';
+    }
+};
+
+} // namespace tlx
+
+#endif // !TLX_LOGGER_UNORDERED_MAP_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/logger/unordered_set.hpp

@@ -0,0 +1,64 @@
+/*******************************************************************************
+ * tlx/logger/unordered_set.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2018 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_LOGGER_UNORDERED_SET_HEADER
+#define TLX_LOGGER_UNORDERED_SET_HEADER
+
+#include <tlx/logger/core.hpp>
+#include <ostream>
+#include <unordered_set>
+
+namespace tlx {
+
+template <typename T, typename H, typename E, typename A>
+class LoggerFormatter<std::unordered_set<T, H, E, A> >
+{
+public:
+    static void print(std::ostream& os,
+                      const std::unordered_set<T, H, E, A>& data)
+    {
+        os << '{';
+        for (typename std::unordered_set<T, H, E, A>::const_iterator it =
+                 data.begin();
+             it != data.end(); ++it)
+        {
+            if (it != data.begin())
+                os << ',';
+            LoggerFormatter<T>::print(os, *it);
+        }
+        os << '}';
+    }
+};
+
+template <typename T, typename H, typename E, typename A>
+class LoggerFormatter<std::unordered_multiset<T, H, E, A> >
+{
+public:
+    static void print(std::ostream& os,
+                      const std::unordered_multiset<T, H, E, A>& data)
+    {
+        os << '{';
+        for (typename std::unordered_multiset<T, H, E, A>::const_iterator it =
+                 data.begin();
+             it != data.end(); ++it)
+        {
+            if (it != data.begin())
+                os << ',';
+            LoggerFormatter<T>::print(os, *it);
+        }
+        os << '}';
+    }
+};
+
+} // namespace tlx
+
+#endif // !TLX_LOGGER_UNORDERED_SET_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/logger/wrap_unprintable.hpp

@@ -0,0 +1,75 @@
+/*******************************************************************************
+ * tlx/logger/wrap_unprintable.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2019 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_LOGGER_WRAP_UNPRINTABLE_HEADER
+#define TLX_LOGGER_WRAP_UNPRINTABLE_HEADER
+
+#include <tlx/meta/enable_if.hpp>
+#include <ostream>
+#include <utility>
+
+namespace tlx {
+
+//! SFINAE magic helper for wrap_unprintable()
+template <typename, typename = void>
+struct has_ostream_operator
+{
+    static constexpr bool value = false;
+};
+
+template <typename Type>
+struct has_ostream_operator<Type, decltype(std::declval<std::ostream&>()
+                                               << std::declval<const Type&>(),
+                                           void())>
+{
+    static constexpr bool value = true;
+};
+
+//! SFINAE magic to return "<unprintable>" instead if the value HAS NO ostream
+//! operator << available.  Identical to shorter wrap_unp().
+template <typename Type>
+typename enable_if<!has_ostream_operator<Type>::value, const char*>::type
+wrap_unprintable(Type, const char* instead = "<unprintable>")
+{
+    return instead;
+}
+
+//! SFINAE magic to return the value if the value HAS a ostream operator <<
+//! available.  Identical to shorter wrap_unp().
+template <typename Type>
+typename enable_if<has_ostream_operator<Type>::value, Type>::type
+wrap_unprintable(Type value, const char* = nullptr)
+{
+    return value;
+}
+
+//! SFINAE magic to return "<unprintable>" instead if the value HAS NO ostream
+//! operator << available.  Shortened name of wrap_unprintable()
+template <typename Type>
+typename enable_if<!has_ostream_operator<Type>::value, const char*>::type
+wrap_unp(Type, const char* instead = "<unprintable>")
+{
+    return instead;
+}
+
+//! SFINAE magic to return the value if the value HAS a ostream operator <<
+//! available.  Shortened name of wrap_unprintable()
+template <typename Type>
+typename enable_if<has_ostream_operator<Type>::value, Type>::type wrap_unp(
+    Type value, const char* = nullptr)
+{
+    return value;
+}
+
+} // namespace tlx
+
+#endif // !TLX_LOGGER_WRAP_UNPRINTABLE_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/logger.hpp

@@ -0,0 +1,44 @@
+/*******************************************************************************
+ * tlx/logger.hpp
+ *
+ * Simple logging methods using ostream output.
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2018 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_LOGGER_HEADER
+#define TLX_LOGGER_HEADER
+
+#include <tlx/logger/core.hpp>
+
+namespace tlx {
+
+//! Explicitly specify the condition for logging
+#define LOGC(cond) TLX_LOGC(cond)
+
+//! Default logging method: output if the local debug variable is true.
+#define LOG LOGC(debug)
+
+//! Override default output: never or always output log.
+#define LOG0 LOGC(false)
+#define LOG1 LOGC(true)
+
+//! Explicitly specify the condition for logging
+#define sLOGC(cond) TLX_sLOGC(cond)
+
+//! Default logging method: output if the local debug variable is true.
+#define sLOG sLOGC(debug)
+
+//! Override default output: never or always output log.
+#define sLOG0 sLOGC(false)
+#define sLOG1 sLOGC(true)
+
+} // namespace tlx
+
+#endif // !TLX_LOGGER_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/math/abs_diff.hpp

@@ -0,0 +1,35 @@
+/*******************************************************************************
+ * tlx/math/abs_diff.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2017 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_MATH_ABS_DIFF_HEADER
+#define TLX_MATH_ABS_DIFF_HEADER
+
+namespace tlx {
+
+//! \addtogroup tlx_math
+//! \{
+
+/******************************************************************************/
+// abs_diff() - calculate absolute difference
+
+//! absolute difference, which also works for unsigned types
+template <typename T>
+T abs_diff(const T& a, const T& b)
+{
+    return a > b ? a - b : b - a;
+}
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_MATH_ABS_DIFF_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/math/aggregate.hpp

@@ -0,0 +1,231 @@
+/*******************************************************************************
+ * tlx/math/aggregate.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2015-2018 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_MATH_AGGREGATE_HEADER
+#define TLX_MATH_AGGREGATE_HEADER
+
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <limits>
+
+namespace tlx {
+
+//! \addtogroup tlx_math
+//! \{
+
+/*!
+ * Calculate running aggregate statistics: feed it with values, and it will keep
+ * the minimum, the maximum, the average, the value number, and the standard
+ * deviation is values.
+ */
+template <typename Type_>
+class Aggregate
+{
+public:
+    using Type = Type_;
+
+    //! default constructor
+    Aggregate() = default;
+
+    //! initializing constructor
+    Aggregate(size_t count, const double& mean, const double& nvar,
+              const Type& min, const Type& max) noexcept : count_(count),
+                                                           mean_(mean),
+                                                           nvar_(nvar),
+                                                           min_(min),
+                                                           max_(max)
+    {
+    }
+
+    //! add a value to the running aggregation
+    Aggregate& add(const Type& value) noexcept
+    {
+        count_++;
+        min_ = std::min(min_, value);
+        max_ = std::max(max_, value);
+        // Single-pass numerically stable mean and standard deviation
+        // calculation as described in Donald Knuth: The Art of Computer
+        // Programming, Volume 2, Chapter 4.2.2, Equations 15 & 16
+        double delta = value - mean_;
+        mean_ += delta / count_;
+        nvar_ += delta * (value - mean_);
+        return *this;
+    }
+
+    //! return number of values aggregated
+    size_t count() const noexcept
+    {
+        return count_;
+    }
+
+    //! return sum over all values aggregated
+    // can't make noexcept since Type_'s conversion is allowed to throw
+    Type sum() const
+    {
+        return static_cast<Type>(count_ * mean_);
+    }
+
+    //! return sum over all values aggregated
+    Type total() const
+    {
+        return sum();
+    }
+
+    //! return the average over all values aggregated
+    double average() const noexcept
+    {
+        return mean_;
+    }
+
+    //! return the average over all values aggregated
+    double avg() const noexcept
+    {
+        return average();
+    }
+
+    //! return the average over all values aggregated
+    double mean() const noexcept
+    {
+        return average();
+    }
+
+    //! return minimum over all values aggregated
+    const Type& min() const noexcept
+    {
+        return min_;
+    }
+
+    //! return maximum over all values aggregated
+    const Type& max() const noexcept
+    {
+        return max_;
+    }
+
+    //! return maximum - minimum over all values aggregated
+    Type span() const noexcept
+    {
+        return max_ - min_;
+    }
+
+    //! return the variance of all values aggregated.
+    //! ddof = delta degrees of freedom
+    //! Set to 0 if you have the entire distribution
+    //! Set to 1 if you have a sample (to correct for bias)
+    double variance(size_t ddof = 1) const
+    {
+        if (count_ <= 1)
+            return 0.0;
+        return nvar_ / static_cast<double>(count_ - ddof);
+    }
+
+    //! return the variance of all values aggregated.
+    //! ddof = delta degrees of freedom
+    //! Set to 0 if you have the entire distribution
+    //! Set to 1 if you have a sample (to correct for bias)
+    double var(size_t ddof = 1) const
+    {
+        return variance(ddof);
+    }
+
+    //! return the standard deviation of all values aggregated.
+    //! ddof = delta degrees of freedom
+    //! Set to 0 if you have the entire distribution
+    //! Set to 1 if you have a sample (to correct for bias)
+    double standard_deviation(size_t ddof = 1) const
+    {
+        return std::sqrt(variance(ddof));
+    }
+
+    //! return the standard deviation of all values aggregated.
+    //! ddof = delta degrees of freedom
+    //! Set to 0 if you have the entire distribution
+    //! Set to 1 if you have a sample (to correct for bias)
+    double stdev(size_t ddof = 1) const
+    {
+        return standard_deviation(ddof);
+    }
+
+    //! operator + to combine two Aggregate<>
+    Aggregate operator+(const Aggregate& a) const noexcept
+    {
+        return Aggregate(
+            // count
+            count_ + a.count_,
+            // mean
+            combine_means(a),
+            // merging variance is a bit complicated
+            combine_variance(a),
+            // min, max
+            std::min(min_, a.min_), std::max(max_, a.max_));
+    }
+
+    //! operator += to combine two Aggregate<>
+    Aggregate& operator+=(const Aggregate& a) noexcept
+    {
+        mean_ = combine_means(a);
+        min_ = std::min(min_, a.min_);
+        max_ = std::max(max_, a.max_);
+        nvar_ = combine_variance(a);
+        count_ += a.count_;
+        return *this;
+    }
+
+    //! serialization method for cereal.
+    template <typename Archive>
+    void serialize(Archive& archive)
+    {
+        archive(count_, mean_, nvar_, min_, max_);
+    }
+
+private:
+    //! combine means, check if either count is zero. fix problems with NaN
+    double combine_means(const Aggregate& a) const noexcept
+    {
+        if (count_ == 0)
+            return a.mean_;
+        if (a.count_ == 0)
+            return mean_;
+        return (mean_ * count_ + a.mean_ * a.count_) / (count_ + a.count_);
+    }
+
+    //! T. Chan et al 1979, "Updating Formulae and a Pairwise Algorithm for
+    //! Computing Sample Variances"
+    double combine_variance(const Aggregate& other) const noexcept
+    {
+        double delta = mean_ - other.mean_;
+        return nvar_ + other.nvar_ +
+               (delta * delta) * (count_ * other.count_) /
+                   (count_ + other.count_);
+    }
+
+    //! number of values aggregated
+    size_t count_ = 0;
+
+    //! mean of values
+    double mean_ = 0.0;
+
+    //! approximate count * variance; stddev = sqrt(nvar / (count-1))
+    double nvar_ = 0.0;
+
+    //! minimum value
+    Type min_ = std::numeric_limits<Type>::max();
+
+    //! maximum value
+    Type max_ = std::numeric_limits<Type>::lowest();
+};
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_MATH_AGGREGATE_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/math/aggregate_min_max.hpp

@@ -0,0 +1,116 @@
+/*******************************************************************************
+ * tlx/math/aggregate_min_max.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2015-2019 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_MATH_AGGREGATE_MIN_MAX_HEADER
+#define TLX_MATH_AGGREGATE_MIN_MAX_HEADER
+
+#include <algorithm>
+#include <limits>
+
+namespace tlx {
+
+//! \addtogroup tlx_math
+//! \{
+
+/*!
+ * Calculate running aggregate statistics: feed it with values, and it will keep
+ * the minimum and the maximum values.
+ */
+template <typename Type_>
+class AggregateMinMax
+{
+public:
+    using Type = Type_;
+
+    //! default constructor
+    AggregateMinMax() = default;
+
+    //! initializing constructor
+    AggregateMinMax(const Type& min, const Type& max) noexcept : min_(min),
+                                                                 max_(max)
+    {
+    }
+
+    //! add a value to the running aggregation
+    AggregateMinMax& add(const Type& value) noexcept
+    {
+        min_ = std::min(min_, value);
+        max_ = std::max(max_, value);
+        return *this;
+    }
+
+    //! return minimum over all values aggregated
+    const Type& min() const noexcept
+    {
+        return min_;
+    }
+
+    //! return maximum over all values aggregated
+    const Type& max() const noexcept
+    {
+        return max_;
+    }
+
+    //! return maximum - minimum over all values aggregated
+    Type span() const noexcept
+    {
+        return max_ - min_;
+    }
+
+    //! change currently aggregated minimum
+    void set_min(const Type& v) noexcept
+    {
+        min_ = v;
+    }
+
+    //! change currently aggregated minimum
+    void set_max(const Type& v) noexcept
+    {
+        max_ = v;
+    }
+
+    //! operator + to combine two AggregateMinMax<>
+    AggregateMinMax operator+(const AggregateMinMax& a) const noexcept
+    {
+        return AggregateMinMax(
+            // min, max
+            std::min(min_, a.min_), std::max(max_, a.max_));
+    }
+
+    //! operator += to combine two AggregateMinMax<>
+    AggregateMinMax& operator+=(const AggregateMinMax& a) noexcept
+    {
+        min_ = std::min(min_, a.min_);
+        max_ = std::max(max_, a.max_);
+        return *this;
+    }
+
+    //! serialization method for cereal.
+    template <typename Archive>
+    void serialize(Archive& archive)
+    {
+        archive(min_, max_);
+    }
+
+private:
+    //! minimum value
+    Type min_ = std::numeric_limits<Type>::max();
+
+    //! maximum value
+    Type max_ = std::numeric_limits<Type>::lowest();
+};
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_MATH_AGGREGATE_MIN_MAX_HEADER
+
+/******************************************************************************/