@ladybugmem/icebug 0.1.0 → 0.1.2

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

@@ -1,66 +0,0 @@
-/*******************************************************************************
- * 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

@@ -1,68 +0,0 @@
-/*******************************************************************************
- * 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

@@ -1,64 +0,0 @@
-/*******************************************************************************
- * 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

@@ -1,75 +0,0 @@
-/*******************************************************************************
- * 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

@@ -1,44 +0,0 @@
-/*******************************************************************************
- * 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

@@ -1,35 +0,0 @@
-/*******************************************************************************
- * 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

@@ -1,231 +0,0 @@
-/*******************************************************************************
- * 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

@@ -1,116 +0,0 @@
-/*******************************************************************************
- * 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
-
-/******************************************************************************/