catboost 1.25.1 → 1.27.0

package/inc/util/random/init_atfork.h

@@ -1,3 +0,0 @@
-#pragma once
-
-void RNGInitAtForkHandlers();

package/inc/util/random/lcg_engine.h

@@ -1,66 +0,0 @@
-#pragma once
-
-#include <utility>
-#include <util/generic/typetraits.h>
-
-// common engine for lcg-based RNG's
-// http://en.wikipedia.org/wiki/Linear_congruential_generator
-
-namespace NPrivate {
-    template <typename T>
-    T LcgAdvance(T seed, T lcgBase, T lcgAddend, T delta) noexcept;
-};
-
-template <typename T, T A, T C>
-struct TFastLcgIterator {
-    static_assert(C % 2 == 1, "C must be odd");
-
-    static constexpr T Iterate(T x) noexcept {
-        return x * A + C;
-    }
-
-    static inline T IterateMultiple(T x, T delta) noexcept {
-        return ::NPrivate::LcgAdvance(x, A, C, delta);
-    }
-};
-
-template <typename T, T A>
-struct TLcgIterator {
-    inline TLcgIterator(T seq) noexcept
-        : C((seq << 1u) | (T)1) // C must be odd
-    {
-    }
-
-    inline T Iterate(T x) noexcept {
-        return x * A + C;
-    }
-
-    inline T IterateMultiple(T x, T delta) noexcept {
-        return ::NPrivate::LcgAdvance(x, A, C, delta);
-    }
-
-    const T C;
-};
-
-template <class TIterator, class TMixer>
-struct TLcgRngBase: public TIterator, public TMixer {
-    using TStateType = decltype(std::declval<TIterator>().Iterate(0));
-    using TResultType = decltype(std::declval<TMixer>().Mix(TStateType()));
-
-    template <typename... Args>
-    inline TLcgRngBase(TStateType seed, Args&&... args)
-        : TIterator(std::forward<Args>(args)...)
-        , X(seed)
-    {
-    }
-
-    inline TResultType GenRand() noexcept {
-        return this->Mix(X = this->Iterate(X));
-    }
-
-    inline void Advance(TStateType delta) noexcept {
-        X = this->IterateMultiple(X, delta);
-    }
-
-    TStateType X;
-};

package/inc/util/random/mersenne.h

@@ -1,46 +0,0 @@
-#pragma once
-
-#include "mersenne64.h"
-#include "mersenne32.h"
-#include "common_ops.h"
-
-namespace NPrivate {
-    template <class T>
-    struct TMersenneTraits;
-
-    template <>
-    struct TMersenneTraits<ui64> {
-        using TImpl = TMersenne64;
-    };
-
-    template <>
-    struct TMersenneTraits<ui32> {
-        using TImpl = TMersenne32;
-    };
-}
-
-class IInputStream;
-
-template <class T>
-class TMersenne: public TCommonRNG<T, TMersenne<T>>, public ::NPrivate::TMersenneTraits<T>::TImpl {
-public:
-    using TBase = typename ::NPrivate::TMersenneTraits<T>::TImpl;
-
-    inline TMersenne() noexcept {
-    }
-
-    inline TMersenne(T seed) noexcept
-        : TBase(seed)
-    {
-    }
-
-    inline TMersenne(IInputStream& pool)
-        : TBase(pool)
-    {
-    }
-
-    inline TMersenne(const T* keys, size_t len) noexcept
-        : TBase(keys, len)
-    {
-    }
-};

package/inc/util/random/mersenne32.h

@@ -1,50 +0,0 @@
-#pragma once
-
-#include <util/system/defaults.h>
-
-class IInputStream;
-
-namespace NPrivate {
-    class TMersenne32 {
-        static constexpr int N = 624;
-
-    public:
-        inline TMersenne32(ui32 s = 19650218UL) noexcept
-            : mti(N + 1)
-        {
-            InitGenRand(s);
-        }
-
-        inline TMersenne32(const ui32* init_key, size_t key_length) noexcept
-            : mti(N + 1)
-        {
-            InitByArray(init_key, key_length);
-        }
-
-        TMersenne32(IInputStream& input);
-
-        inline ui32 GenRand() noexcept {
-            if (mti >= N) {
-                InitNext();
-            }
-
-            ui32 y = mt[mti++];
-
-            y ^= (y >> 11);
-            y ^= (y << 7) & 0x9d2c5680UL;
-            y ^= (y << 15) & 0xefc60000UL;
-            y ^= (y >> 18);
-
-            return y;
-        }
-
-    private:
-        void InitNext() noexcept;
-        void InitGenRand(ui32 s) noexcept;
-        void InitByArray(const ui32* init_key, size_t key_length) noexcept;
-
-    private:
-        ui32 mt[N];
-        int mti;
-    };
-}

package/inc/util/random/mersenne64.h

@@ -1,50 +0,0 @@
-#pragma once
-
-#include <util/system/defaults.h>
-
-class IInputStream;
-
-namespace NPrivate {
-    class TMersenne64 {
-        static constexpr int NN = 312;
-
-    public:
-        inline TMersenne64(ui64 s = ULL(19650218))
-            : mti(NN + 1)
-        {
-            InitGenRand(s);
-        }
-
-        inline TMersenne64(const ui64* keys, size_t len) noexcept
-            : mti(NN + 1)
-        {
-            InitByArray(keys, len);
-        }
-
-        TMersenne64(IInputStream& input);
-
-        inline ui64 GenRand() noexcept {
-            if (mti >= NN) {
-                InitNext();
-            }
-
-            ui64 x = mt[mti++];
-
-            x ^= (x >> 29) & ULL(0x5555555555555555);
-            x ^= (x << 17) & ULL(0x71D67FFFEDA60000);
-            x ^= (x << 37) & ULL(0xFFF7EEE000000000);
-            x ^= (x >> 43);
-
-            return x;
-        }
-
-    private:
-        void InitNext() noexcept;
-        void InitGenRand(ui64 seed) noexcept;
-        void InitByArray(const ui64* init_key, size_t key_length) noexcept;
-
-    private:
-        ui64 mt[NN];
-        int mti;
-    };
-}

package/inc/util/random/normal.h

@@ -1,38 +0,0 @@
-#pragma once
-
-#include <cmath>
-
-// sometimes we need stateless normal distribution...
-
-/*
- * normal distribution with Box-Muller transform
- * http://www.design.caltech.edu/erik/Misc/Gaussian.html
- */
-template <typename T, typename TRng>
-static inline T StdNormalDistribution(TRng&& rng) noexcept {
-    T x;
-    T y;
-    T r;
-
-    do {
-        x = (T)rng.GenRandReal1() * T(2) - T(1);
-        y = (T)rng.GenRandReal1() * T(2) - T(1);
-        r = x * x + y * y;
-    } while (r > T(1) || r <= T(0));
-
-    return x * std::sqrt(-T(2) * std::log(r) / r);
-}
-
-template <typename T, typename TRng>
-static inline T NormalDistribution(TRng&& rng, T m, T d) noexcept {
-    return StdNormalDistribution<T>(rng) * d + m;
-}
-
-// specialized for float, double, long double
-template <class T>
-T StdNormalRandom() noexcept;
-
-template <class T>
-static inline T NormalRandom(T m, T d) noexcept {
-    return StdNormalRandom<T>() * d + m;
-}

package/inc/util/random/random.h

@@ -1,30 +0,0 @@
-#pragma once
-
-/*
- * thread-safe random number generator.
- *
- * specialized for:
- *  all unsigned types (return value in range [0, MAX_VALUE_FOR_TYPE])
- *  bool
- *  long double (return value in range [0, 1))
- *  double (return value in range [0, 1))
- *  float (return value in range [0, 1))
- */
-template <class T>
-T RandomNumber();
-
-/*
- * returns value in range [0, max)
- */
-template <class T>
-T RandomNumber(T max);
-
-/*
- * Re-initialize random state - useful after forking in multi-process programs.
- */
-void ResetRandomState();
-
-/*
- * Set random SEED
- */
-void SetRandomSeed(int seed);

package/inc/util/random/shuffle.h

@@ -1,39 +0,0 @@
-#pragma once
-
-#include "fast.h"
-#include "entropy.h"
-
-#include <util/generic/utility.h>
-
-// some kind of https://en.wikipedia.org/wiki/Fisher–Yates_shuffle#The_modern_algorithm
-
-template <typename TRandIter, typename TRandIterEnd>
-inline void Shuffle(TRandIter begin, TRandIterEnd end) {
-    static_assert(sizeof(end - begin) <= sizeof(size_t), "fixme");
-    static_assert(sizeof(TReallyFastRng32::RandMax()) <= sizeof(size_t), "fixme");
-
-    if ((size_t)(end - begin) < (size_t)TReallyFastRng32::RandMax()) {
-        Shuffle(begin, end, TReallyFastRng32(Seed()));
-    } else {
-        Shuffle(begin, end, TFastRng64(Seed()));
-    }
-}
-
-template <typename TRandIter, typename TRandIterEnd, typename TRandGen>
-inline void Shuffle(TRandIter begin, TRandIterEnd end, TRandGen&& gen) {
-    const size_t sz = end - begin;
-
-    for (size_t i = 1; i < sz; ++i) {
-        DoSwap(*(begin + i), *(begin + gen.Uniform(i + 1)));
-    }
-}
-
-template <typename TRange>
-inline void ShuffleRange(TRange& range) {
-    Shuffle(range.begin(), range.end());
-}
-
-template <typename TRange, typename TRandGen>
-inline void ShuffleRange(TRange& range, TRandGen&& gen) {
-    Shuffle(range.begin(), range.end(), gen);
-}

package/inc/util/str_stl.h

@@ -1,266 +0,0 @@
-#pragma once
-
-#include <util/memory/alloc.h>
-#include <util/digest/numeric.h>
-#include <util/generic/string.h>
-#include <util/generic/string_hash.h>
-#include <util/generic/strbuf.h>
-#include <util/generic/typetraits.h>
-
-#include <utility>
-#include <functional>
-
-namespace std {
-    template <>
-    struct less<const char*> {
-        bool operator()(const char* x, const char* y) const {
-            return strcmp(x, y) < 0;
-        }
-    };
-    template <>
-    struct equal_to<const char*> {
-        bool operator()(const char* x, const char* y) const {
-            return strcmp(x, y) == 0;
-        }
-        bool operator()(const char* x, const TStringBuf y) const {
-            return strlen(x) == y.size() && memcmp(x, y.data(), y.size()) == 0;
-        }
-        using is_transparent = void;
-    };
-}
-
-namespace NHashPrivate {
-    template <class T, bool needNumericHashing>
-    struct THashHelper {
-        inline size_t operator()(const T& t) const noexcept {
-            return (size_t)t; // If you have a compilation error here, look at explanation below:
-            // Probably error is caused by undefined template specialization of THash<T>
-            // You can find examples of specialization in this file
-        }
-    };
-
-    template <class T>
-    struct THashHelper<T, true> {
-        inline size_t operator()(const T& t) const noexcept {
-            return NumericHash(t);
-        }
-    };
-
-    template <typename C>
-    struct TStringHash {
-        using is_transparent = void;
-
-        inline size_t operator()(const TBasicStringBuf<C> s) const noexcept {
-            return NHashPrivate::ComputeStringHash(s.data(), s.size());
-        }
-    };
-}
-
-template <class T>
-struct hash: public NHashPrivate::THashHelper<T, std::is_scalar<T>::value && !std::is_integral<T>::value> {
-};
-
-template <typename T>
-struct hash<const T*> {
-    inline size_t operator()(const T* t) const noexcept {
-        return NumericHash(t);
-    }
-};
-
-template <class T>
-struct hash<T*>: public ::hash<const T*> {
-};
-
-template <>
-struct hash<const char*> : ::NHashPrivate::TStringHash<char> {
-};
-
-template <>
-struct THash<TStringBuf> : ::NHashPrivate::TStringHash<char> {
-};
-
-template <>
-struct hash<TString> : ::NHashPrivate::TStringHash<char> {
-};
-
-template <>
-struct hash<TUtf16String> : ::NHashPrivate::TStringHash<wchar16> {
-};
-
-template <>
-struct THash<TWtringBuf> : ::NHashPrivate::TStringHash<wchar16> {
-};
-
-template <>
-struct hash<TUtf32String> : ::NHashPrivate::TStringHash<wchar32> {
-};
-
-template <>
-struct THash<TUtf32StringBuf> : ::NHashPrivate::TStringHash<wchar32> {
-};
-
-template <class C, class T, class A>
-struct hash<std::basic_string<C, T, A>> : ::NHashPrivate::TStringHash<C> {
-};
-
-namespace NHashPrivate {
-    template <typename T>
-    Y_FORCE_INLINE static size_t HashObject(const T& val) {
-        return THash<T>()(val);
-    }
-
-    template <size_t I, bool IsLastElement, typename... TArgs>
-    struct TupleHashHelper {
-        Y_FORCE_INLINE static size_t Hash(const std::tuple<TArgs...>& tuple) {
-            return CombineHashes(HashObject(std::get<I>(tuple)),
-                                 TupleHashHelper<I + 1, I + 2 >= sizeof...(TArgs), TArgs...>::Hash(tuple));
-        }
-    };
-
-    template <size_t I, typename... TArgs>
-    struct TupleHashHelper<I, true, TArgs...> {
-        Y_FORCE_INLINE static size_t Hash(const std::tuple<TArgs...>& tuple) {
-            return HashObject(std::get<I>(tuple));
-        }
-    };
-
-}
-
-template <typename... TArgs>
-struct THash<std::tuple<TArgs...>> {
-    size_t operator()(const std::tuple<TArgs...>& tuple) const {
-        return NHashPrivate::TupleHashHelper<0, 1 >= sizeof...(TArgs), TArgs...>::Hash(tuple);
-    }
-};
-
-template <class T>
-struct THash: public ::hash<T> {
-};
-
-namespace NHashPrivate {
-    template <class TFirst, class TSecond, bool IsEmpty = std::is_empty<THash<TFirst>>::value&& std::is_empty<THash<TSecond>>::value>
-    struct TPairHash {
-    private:
-        THash<TFirst> FirstHash;
-        THash<TSecond> SecondHash;
-
-    public:
-        template <class T>
-        inline size_t operator()(const T& pair) const {
-            return CombineHashes(FirstHash(pair.first), SecondHash(pair.second));
-        }
-    };
-
-    /**
-     * Specialization for the case where both hash functors are empty. Basically the
-     * only one we care about. We don't introduce additional specializations for
-     * cases where only one of the functors is empty as the code bloat is just not worth it.
-     */
-    template <class TFirst, class TSecond>
-    struct TPairHash<TFirst, TSecond, true> {
-        template <class T>
-        inline size_t operator()(const T& pair) const {
-            // maps have TFirst = const TFoo, which would make for an undefined specialization
-            using TFirstClean = std::remove_cv_t<TFirst>;
-            using TSecondClean = std::remove_cv_t<TSecond>;
-            return CombineHashes(THash<TFirstClean>()(pair.first), THash<TSecondClean>()(pair.second));
-        }
-    };
-}
-
-template <class TFirst, class TSecond>
-struct hash<std::pair<TFirst, TSecond>>: public NHashPrivate::TPairHash<TFirst, TSecond> {
-};
-
-
-
-template <class T>
-struct TEqualTo: public std::equal_to<T> {
-};
-
-template <>
-struct TEqualTo<TString>: public TEqualTo<TStringBuf> {
-    using is_transparent = void;
-};
-
-template <>
-struct TEqualTo<TUtf16String>: public TEqualTo<TWtringBuf> {
-    using is_transparent = void;
-};
-
-template <>
-struct TEqualTo<TUtf32String> : public TEqualTo<TUtf32StringBuf> {
-    using is_transparent = void;
-};
-
-template <class TFirst, class TSecond>
-struct TEqualTo<std::pair<TFirst, TSecond>> {
-    template <class TOther>
-    inline bool operator()(const std::pair<TFirst, TSecond>& a, const TOther& b) const {
-        return TEqualTo<TFirst>()(a.first, b.first) && TEqualTo<TSecond>()(a.second, b.second);
-    }
-    using is_transparent = void;
-};
-
-template <class T>
-struct TCIEqualTo {
-};
-
-template <>
-struct TCIEqualTo<const char*> {
-    inline bool operator()(const char* a, const char* b) const {
-        return stricmp(a, b) == 0;
-    }
-};
-
-template <>
-struct TCIEqualTo<TStringBuf> {
-    inline bool operator()(const TStringBuf a, const TStringBuf b) const {
-        return a.size() == b.size() && strnicmp(a.data(), b.data(), a.size()) == 0;
-    }
-};
-
-template <>
-struct TCIEqualTo<TString> {
-    inline bool operator()(const TString& a, const TString& b) const {
-        return a.size() == b.size() && strnicmp(a.data(), b.data(), a.size()) == 0;
-    }
-};
-
-template <class T>
-struct TLess: public std::less<T> {
-};
-
-template <>
-struct TLess<TString>: public TLess<TStringBuf> {
-    using is_transparent = void;
-};
-
-template <>
-struct TLess<TUtf16String>: public TLess<TWtringBuf> {
-    using is_transparent = void;
-};
-
-template <>
-struct TLess<TUtf32String> : public TLess<TUtf32StringBuf> {
-    using is_transparent = void;
-};
-
-template <class T>
-struct TGreater: public std::greater<T> {
-};
-
-template <>
-struct TGreater<TString>: public TGreater<TStringBuf> {
-    using is_transparent = void;
-};
-
-template <>
-struct TGreater<TUtf16String>: public TGreater<TWtringBuf> {
-    using is_transparent = void;
-};
-
-template <>
-struct TGreater<TUtf32String> : public TGreater<TUtf32StringBuf> {
-    using is_transparent = void;
-};

package/inc/util/stream/aligned.h

@@ -1,99 +0,0 @@
-#pragma once
-
-#include "input.h"
-#include "output.h"
-
-#include <util/system/yassert.h>
-#include <util/generic/bitops.h>
-
-/**
- * @addtogroup Streams
- * @{
- */
-
-/**
- * Proxy input stream that provides additional functions that make reading
- * aligned data easier.
- */
-class TAlignedInput: public IInputStream {
-public:
-    TAlignedInput(IInputStream* s)
-        : Stream_(s)
-        , Position_(0)
-    {
-    }
-
-    /**
-     * Ensures alignment of the position in the input stream by skipping
-     * some input.
-     *
-     * @param alignment                 Alignment. Must be a power of 2.
-     */
-    void Align(size_t alignment = sizeof(void*)) {
-        Y_ASSERT(IsPowerOf2(alignment));
-
-        if (Position_ & (alignment - 1)) {
-            size_t len = alignment - (Position_ & (alignment - 1));
-
-            do {
-                len -= DoSkip(len);
-            } while (len);
-        }
-    }
-
-private:
-    size_t DoRead(void* ptr, size_t len) override;
-    size_t DoSkip(size_t len) override;
-    size_t DoReadTo(TString& st, char ch) override;
-    ui64 DoReadAll(IOutputStream& out) override;
-
-private:
-    IInputStream* Stream_;
-    ui64 Position_;
-};
-
-/**
- * Proxy output stream that provides additional functions that make writing
- * aligned data easier.
- */
-class TAlignedOutput: public IOutputStream {
-public:
-    TAlignedOutput(IOutputStream* s)
-        : Stream_(s)
-        , Position_(0)
-    {
-    }
-
-    TAlignedOutput(TAlignedOutput&&) noexcept = default;
-    TAlignedOutput& operator=(TAlignedOutput&&) noexcept = default;
-
-    size_t GetCurrentOffset() const {
-        return Position_;
-    }
-
-    /**
-     * Ensures alignment of the position in the output stream by writing
-     * some data.
-     *
-     * @param alignment                 Alignment. Must be a power of 2.
-     */
-    void Align(size_t alignment = sizeof(void*)) {
-        Y_ASSERT(IsPowerOf2(alignment));
-
-        static char unused[sizeof(void*) * 2];
-        Y_ASSERT(alignment <= sizeof(unused));
-
-        if (Position_ & (alignment - 1)) {
-            DoWrite(unused, alignment - (Position_ & (alignment - 1)));
-        }
-    }
-
-private:
-    void DoWrite(const void* ptr, size_t len) override;
-
-private:
-    IOutputStream* Stream_;
-    ui64 Position_;
-};
-
-/** @} */