catboost 1.25.1 → 1.27.0

package/inc/util/generic/yexception.h

@@ -1,212 +0,0 @@
-#pragma once
-
-#include "bt_exception.h"
-#include "strbuf.h"
-#include "string.h"
-#include "utility.h"
-#include "va_args.h"
-#include <utility>
-
-#include <util/stream/tempbuf.h>
-#include <util/system/compat.h>
-#include <util/system/compiler.h>
-#include <util/system/defaults.h>
-#include <util/system/error.h>
-#include <util/system/src_location.h>
-
-#include <exception>
-
-#include <cstdio>
-
-class TBackTrace;
-
-namespace NPrivateException {
-    class TTempBufCuttingWrapperOutput: public IOutputStream {
-    public:
-        TTempBufCuttingWrapperOutput(TTempBuf& tempbuf)
-            : TempBuf_(tempbuf)
-        {
-        }
-
-        void DoWrite(const void* data, size_t len) override {
-            TempBuf_.Append(data, Min(len, TempBuf_.Left()));
-        }
-
-    private:
-        TTempBuf& TempBuf_;
-    };
-
-    class yexception: public std::exception {
-    public:
-        yexception();
-        yexception(const yexception&) = default;
-        yexception(yexception&&) = default;
-
-        yexception& operator=(const yexception&) = default;
-        yexception& operator=(yexception&&) = default;
-
-        const char* what() const noexcept override;
-        virtual const TBackTrace* BackTrace() const noexcept;
-
-        template <class T>
-        inline void Append(const T& t) {
-            TTempBufCuttingWrapperOutput tempBuf(Buf_);
-            static_cast<IOutputStream&>(tempBuf) << t;
-            ZeroTerminate();
-        }
-
-        TStringBuf AsStrBuf() const;
-
-    private:
-        void ZeroTerminate() noexcept;
-
-    private:
-        TTempBuf Buf_;
-    };
-
-    template <class E, class T>
-    static inline E&& operator<<(E&& e, const T& t) {
-        e.Append(t);
-
-        return std::forward<E>(e);
-    }
-
-    template <class T>
-    static inline T&& operator+(const TSourceLocation& sl, T&& t) {
-        return std::forward<T>(t << sl << TStringBuf(": "));
-    }
-}
-
-class yexception: public NPrivateException::yexception {
-};
-
-Y_DECLARE_OUT_SPEC(inline, yexception, stream, value) {
-    stream << value.AsStrBuf();
-}
-
-class TSystemError: public yexception {
-public:
-    TSystemError(int status)
-        : Status_(status)
-    {
-        Init();
-    }
-
-    TSystemError()
-        : TSystemError(LastSystemError())
-    {}
-
-    int Status() const noexcept {
-        return Status_;
-    }
-
-private:
-    void Init();
-
-private:
-    int Status_;
-};
-
-class TIoException: public TSystemError {
-};
-
-class TIoSystemError: public TIoException {
-};
-
-class TFileError: public TIoSystemError {
-};
-
-/**
- * TBadArgumentException should be thrown when an argument supplied to some function (or constructor)
- * is invalid or incorrect.
- *
- * \note
- * A special case when such argument is given to a function which performs type casting
- * (e.g. integer from string) is covered by the TBadCastException class which is derived from
- * TBadArgumentException.
- */
-struct TBadArgumentException: public virtual yexception {
-};
-
-/**
- * TBadCastException should be thrown to indicate the failure of some type casting procedure
- * (e.g. reading an integer parameter from string).
- */
-struct TBadCastException: public virtual TBadArgumentException {
-};
-
-#define ythrow throw __LOCATION__ +
-
-namespace NPrivate {
-    /// Encapsulates data for one of the most common case in which
-    /// exception message contists of single constant string
-    struct TSimpleExceptionMessage {
-        TSourceLocation Location;
-        TStringBuf Message;
-    };
-
-    [[noreturn]] void ThrowYException(const TSimpleExceptionMessage& sm);
-    [[noreturn]] void ThrowYExceptionWithBacktrace(const TSimpleExceptionMessage& sm);
-}
-
-void fputs(const std::exception& e, FILE* f = stderr);
-
-TString CurrentExceptionMessage();
-bool UncaughtException() noexcept;
-
-TString FormatExc(const std::exception& exception);
-
-#define Y_ENSURE_EX(CONDITION, THROW_EXPRESSION) \
-    do {                                         \
-        if (Y_UNLIKELY(!(CONDITION))) {          \
-            ythrow THROW_EXPRESSION;             \
-        }                                        \
-    } while (false)
-
-/// @def Y_ENSURE_SIMPLE
-/// This macro works like the Y_ENSURE, but requires the second argument to be a constant string view.
-/// Should not be used directly.
-#define Y_ENSURE_SIMPLE(CONDITION, MESSAGE, THROW_FUNCTION)                                                                 \
-    do {                                                                                                                    \
-        if (Y_UNLIKELY(!(CONDITION))) {                                                                                     \
-            /* use variable to guarantee evaluation at compile time */                                                      \
-            static constexpr const ::NPrivate::TSimpleExceptionMessage __SIMPLE_EXCEPTION_MESSAGE{__LOCATION__, (MESSAGE)}; \
-            THROW_FUNCTION(__SIMPLE_EXCEPTION_MESSAGE);                                                                     \
-        }                                                                                                                   \
-    } while (false)
-
-#define Y_ENSURE_IMPL_1(CONDITION) Y_ENSURE_SIMPLE(CONDITION, ::TStringBuf("Condition violated: `" Y_STRINGIZE(CONDITION) "'"), ::NPrivate::ThrowYException)
-#define Y_ENSURE_IMPL_2(CONDITION, MESSAGE) Y_ENSURE_EX(CONDITION, yexception() << MESSAGE)
-
-#define Y_ENSURE_BT_IMPL_1(CONDITION) Y_ENSURE_SIMPLE(CONDITION, ::TStringBuf("Condition violated: `" Y_STRINGIZE(CONDITION) "'"), ::NPrivate::ThrowYExceptionWithBacktrace)
-#define Y_ENSURE_BT_IMPL_2(CONDITION, MESSAGE) Y_ENSURE_EX(CONDITION, TWithBackTrace<yexception>() << MESSAGE)
-
-/**
- * @def Y_ENSURE
- *
- * This macro is inteded to use as a shortcut for `if () { throw }`.
- *
- * @code
- * void DoSomethingLovely(const int x, const int y) {
- *     Y_ENSURE(x > y, "`x` must be greater than `y`");
- *     Y_ENSURE(x > y); // if you are too lazy
- *     // actually doing something nice here
- * }
- * @endcode
- */
-#define Y_ENSURE(...) Y_PASS_VA_ARGS(Y_MACRO_IMPL_DISPATCHER_2(__VA_ARGS__, Y_ENSURE_IMPL_2, Y_ENSURE_IMPL_1)(__VA_ARGS__))
-
-/**
- * @def Y_ENSURE_BT
- *
- * This macro is inteded to use as a shortcut for `if () { throw TWithBackTrace<yexception>() << "message"; }`.
- *
- * @code
- * void DoSomethingLovely(const int x, const int y) {
- *     Y_ENSURE_BT(x > y, "`x` must be greater than `y`");
- *     Y_ENSURE_BT(x > y); // if you are too lazy
- *     // actually doing something nice here
- * }
- * @endcode
- */
-#define Y_ENSURE_BT(...) Y_PASS_VA_ARGS(Y_MACRO_IMPL_DISPATCHER_2(__VA_ARGS__, Y_ENSURE_BT_IMPL_2, Y_ENSURE_BT_IMPL_1)(__VA_ARGS__))

package/inc/util/generic/yexception_ut.h

@@ -1,14 +0,0 @@
-#pragma once
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef void (*TCallbackFun)(int);
-
-//! just calls callback with parameter @c i
-void TestCallback(TCallbackFun f, int i);
-
-#ifdef __cplusplus
-}
-#endif

package/inc/util/generic/ylimits.h

@@ -1,92 +0,0 @@
-#pragma once
-
-#include <limits>
-
-#if defined(max) || defined(min)
-#error "stop defining 'min' and 'max' macros, evil people"
-#endif
-
-template <class T>
-static constexpr T Max() noexcept {
-    return std::numeric_limits<T>::max();
-}
-
-template <class T>
-static constexpr T Min() noexcept {
-    return std::numeric_limits<T>::min();
-}
-
-namespace NPrivate {
-    struct TMax {
-        template <class T>
-        constexpr operator T() const {
-            return Max<T>();
-        }
-    };
-
-    struct TMin {
-        template <class T>
-        constexpr operator T() const {
-            return Min<T>();
-        }
-    };
-}
-
-static constexpr ::NPrivate::TMax Max() noexcept {
-    return {};
-}
-
-static constexpr ::NPrivate::TMin Min() noexcept {
-    return {};
-}
-
-namespace NPrivate {
-    template <unsigned long long N>
-    static constexpr double MaxFloorValue() {
-        return N;
-    }
-    template <unsigned long long N>
-    static constexpr double MaxCeilValue() {
-        return N;
-    }
-    template <>
-    constexpr double MaxFloorValue<0x7FFF'FFFF'FFFF'FFFFull>() {
-        return 9223372036854774784.0; // 0x7FFFFFFFFFFFFC00p0
-    }
-    template <>
-    constexpr double MaxCeilValue<0x7FFF'FFFF'FFFF'FFFFull>() {
-        return 9223372036854775808.0; // 0x8000000000000000p0
-    }
-    template <>
-    constexpr double MaxFloorValue<0xFFFF'FFFF'FFFF'FFFFull>() {
-        return 18446744073709549568.0; // 0xFFFFFFFFFFFFF800p0
-    }
-    template <>
-    constexpr double MaxCeilValue<0xFFFF'FFFF'FFFF'FFFFull>() {
-        return 18446744073709551616.0; // 0x10000000000000000p0
-    }
-}
-
-// MaxFloor<T> is the greatest double within the range of T.
-//
-// 1. If Max<T> is an exact double, MaxFloor<T> = Max<T> = MaxCeil<T>.
-//    In this case some doubles above MaxFloor<T> cast to T may round
-//    to Max<T> depending on the rounding mode.
-//
-// 2. Otherwise Max<T> is between MaxFloor<T> and MaxCeil<T>, and
-//    MaxFloor<T> is the largest double that does not overflow T.
-template <class T>
-static constexpr double MaxFloor() noexcept {
-    return ::NPrivate::MaxFloorValue<Max<T>()>();
-}
-
-// MaxCeil<T> is the smallest double not lesser than Max<T>.
-//
-// 1. If Max<T> is an exact double, MaxCeil<T> = Max<T> = MaxFloor<T>.
-//
-// 2. Otherwise Max<T> is between MaxFloor<T> and MaxCeil<T>, and
-//    MaxCeil<T> is the smallest double that overflows T.
-template <class T>
-static constexpr double MaxCeil() noexcept {
-    return ::NPrivate::MaxCeilValue<Max<T>()>();
-}

package/inc/util/generic/ymath.h

@@ -1,206 +0,0 @@
-#pragma once
-
-#include <util/system/yassert.h>
-#include <util/system/defaults.h>
-
-#include <cmath>
-#include <cfloat>
-#include <cstdlib>
-
-#include "typetraits.h"
-#include "utility.h"
-
-constexpr double PI = M_PI;
-constexpr double M_LOG2_10 = 3.32192809488736234787; // log2(10)
-constexpr double M_LN2_INV = M_LOG2E;                // 1 / ln(2) == log2(e)
-
-/**
- * \returns                             Absolute value of the provided argument.
- */
-template <class T>
-constexpr T Abs(T value) {
-    return std::abs(value);
-}
-
-/**
- * @returns                             Base 2 logarithm of the provided double
- *                                      precision floating point value.
- */
-inline double Log2(double value) {
-    return log(value) * M_LN2_INV;
-}
-
-/**
- * @returns                             Base 2 logarithm of the provided
- *                                      floating point value.
- */
-inline float Log2(float value) {
-    return logf(value) * static_cast<float>(M_LN2_INV);
-}
-
-/**
- * @returns                             Base 2 logarithm of the provided integral value.
- */
-template <class T>
-inline std::enable_if_t<std::is_integral<T>::value, double>
-Log2(T value) {
-    return Log2(static_cast<double>(value));
-}
-
-/** Returns 2^x */
-double Exp2(double);
-float Exp2f(float);
-
-template <class T>
-static constexpr T Sqr(const T t) noexcept {
-    return t * t;
-}
-
-inline double Sigmoid(double x) {
-    return 1.0 / (1.0 + std::exp(-x));
-}
-
-inline float Sigmoid(float x) {
-    return 1.0f / (1.0f + std::exp(-x));
-}
-
-static inline bool IsFinite(double f) {
-#if defined(isfinite)
-    return isfinite(f);
-#elif defined(_win_)
-    return _finite(f) != 0;
-#elif defined(_darwin_)
-    return isfinite(f);
-#elif defined(__GNUC__)
-    return __builtin_isfinite(f);
-#elif defined(_STLP_VENDOR_STD)
-    return _STLP_VENDOR_STD::isfinite(f);
-#else
-    return std::isfinite(f);
-#endif
-}
-
-static inline bool IsNan(double f) {
-#if defined(_win_)
-    return _isnan(f) != 0;
-#else
-    return std::isnan(f);
-#endif
-}
-
-inline bool IsValidFloat(double f) {
-    return IsFinite(f) && !IsNan(f);
-}
-
-#ifdef _MSC_VER
-double Erf(double x);
-#else
-inline double Erf(double x) {
-    return erf(x);
-}
-#endif
-
-/**
- * @returns                             Natural logarithm of the absolute value
- *                                      of the gamma function of provided argument.
- */
-inline double LogGamma(double x) noexcept {
-#if defined(_glibc_)
-    int sign;
-
-    (void)sign;
-
-    return lgamma_r(x, &sign);
-#elif defined(__GNUC__)
-    return __builtin_lgamma(x);
-#elif defined(_unix_)
-    return lgamma(x);
-#else
-    extern double LogGammaImpl(double);
-    return LogGammaImpl(x);
-#endif
-}
-
-/**
- * @returns                             x^n for integer n, n >= 0.
- */
-template <class T, class Int>
-T Power(T x, Int n) {
-    static_assert(std::is_integral<Int>::value, "only integer powers are supported");
-    Y_ASSERT(n >= 0);
-    if (n == 0) {
-        return T(1);
-    }
-    while ((n & 1) == 0) {
-        x = x * x;
-        n >>= 1;
-    }
-    T result = x;
-    n >>= 1;
-    while (n > 0) {
-        x = x * x;
-        if (n & 1) {
-            result = result * x;
-        }
-        n >>= 1;
-    }
-    return result;
-};
-
-/**
- * Compares two floating point values and returns true if they are considered equal.
- * The two numbers are compared in a relative way, where the exactness is stronger
- * the smaller the numbers are.
- *
- * Note that comparing values where either one is 0.0 will not work.
- * The solution to this is to compare against values greater than or equal to 1.0.
- *
- * @code
- * // Instead of comparing with 0.0
- * FuzzyEquals(0.0, 1.0e-200); // This will return false
- * // Compare adding 1 to both values will fix the problem
- * FuzzyEquals(1 + 0.0, 1 + 1.0e-200); // This will return true
- * @endcode
- */
-inline bool FuzzyEquals(double p1, double p2, double eps = 1.0e-13) {
-    return (Abs(p1 - p2) <= eps * Min(Abs(p1), Abs(p2)));
-}
-
-/**
- * @see FuzzyEquals(double, double, double)
- */
-inline bool FuzzyEquals(float p1, float p2, float eps = 1.0e-6) {
-    return (Abs(p1 - p2) <= eps * Min(Abs(p1), Abs(p2)));
-}
-
-namespace NUtilMathPrivate {
-    template <bool IsSigned>
-    struct TCeilDivImpl {};
-
-    template <>
-    struct TCeilDivImpl<true> {
-        template <class T>
-        static inline T Do(T x, T y) noexcept {
-            return x / y + (((x < 0) ^ (y > 0)) && (x % y));
-        }
-    };
-
-    template <>
-    struct TCeilDivImpl<false> {
-        template <class T>
-        static inline T Do(T x, T y) noexcept {
-            auto quot = x / y;
-            return (x % y) ? (quot + 1) : quot;
-        }
-    };
-}
-
-/**
- * @returns Equivalent to ceil((double) x / (double) y) but using only integer arithmetic operations
- */
-template <class T>
-inline T CeilDiv(T x, T y) noexcept {
-    static_assert(std::is_integral<T>::value, "Integral type required.");
-    Y_ASSERT(y != 0);
-    return ::NUtilMathPrivate::TCeilDivImpl<std::is_signed<T>::value>::Do(x, y);
-}

package/inc/util/memory/addstorage.h

@@ -1,93 +0,0 @@
-#pragma once
-
-#include <util/system/align.h>
-#include <util/system/defaults.h>
-
-#include <new>
-
-namespace NPrivate {
-    class TAdditionalStorageInfo {
-    public:
-        constexpr TAdditionalStorageInfo(size_t length) noexcept
-            : Length_(length)
-        {
-        }
-
-        constexpr size_t Length() const noexcept {
-            return Length_;
-        }
-
-    private:
-        size_t Length_;
-    };
-}
-
-template <class T>
-class alignas(::NPrivate::TAdditionalStorageInfo) TAdditionalStorage {
-    using TInfo = ::NPrivate::TAdditionalStorageInfo;
-
-public:
-    inline TAdditionalStorage() noexcept = default;
-
-    inline ~TAdditionalStorage() = default;
-
-    inline void* operator new(size_t len1, size_t len2) {
-        static_assert(alignof(T) >= alignof(TInfo));
-        Y_ASSERT(len1 == sizeof(T));
-        void* data = ::operator new(CombinedSizeOfInstanceWithTInfo() + len2);
-        void* info = InfoPtr(static_cast<T*>(data));
-        Y_UNUSED(new (info) TInfo(len2));
-
-        return data;
-    }
-
-    inline void operator delete(void* ptr) noexcept {
-        DoDelete(ptr);
-    }
-
-    inline void operator delete(void* ptr, size_t) noexcept {
-        DoDelete(ptr);
-    }
-
-    inline void operator delete(void* ptr, size_t, size_t) noexcept {
-        /*
-         * this delete operator can be called automagically by compiler
-         */
-
-        DoDelete(ptr);
-    }
-
-    inline void* AdditionalData() const noexcept {
-        return (char*)(static_cast<const T*>(this)) + CombinedSizeOfInstanceWithTInfo();
-    }
-
-    static inline T* ObjectFromData(void* data) noexcept {
-        return reinterpret_cast<T*>(static_cast<char*>(data) - CombinedSizeOfInstanceWithTInfo());
-    }
-
-    inline size_t AdditionalDataLength() const noexcept {
-        return InfoPtr(static_cast<const T*>(this))->Length();
-    }
-
-private:
-    static inline void DoDelete(void* ptr) noexcept {
-        TInfo* info = InfoPtr(static_cast<T*>(ptr));
-        info->~TInfo();
-        ::operator delete(ptr);
-    }
-
-    static constexpr size_t CombinedSizeOfInstanceWithTInfo() noexcept {
-        return AlignUp(sizeof(T), alignof(TInfo)) + sizeof(TInfo);
-    }
-
-    static constexpr TInfo* InfoPtr(T* instance) noexcept {
-        return const_cast<TInfo*>(InfoPtr(static_cast<const T*>(instance)));
-    }
-
-    static constexpr const TInfo* InfoPtr(const T* instance) noexcept {
-        return reinterpret_cast<const TInfo*>(reinterpret_cast<const char*>(instance) + CombinedSizeOfInstanceWithTInfo() - sizeof(TInfo));
-    }
-
-private:
-    void* operator new(size_t) = delete;
-};

package/inc/util/memory/alloc.h

@@ -1,27 +0,0 @@
-#pragma once
-
-#include <memory>
-
-template <class Allocator, class T>
-using TReboundAllocator = typename std::allocator_traits<Allocator>::template rebind_alloc<T>;
-
-class IAllocator {
-public:
-    struct TBlock {
-        void* Data;
-        size_t Len;
-    };
-
-    virtual ~IAllocator() = default;
-
-    virtual TBlock Allocate(size_t len) = 0;
-    virtual void Release(const TBlock& block) = 0;
-};
-
-class TDefaultAllocator: public IAllocator {
-public:
-    TBlock Allocate(size_t len) override;
-    void Release(const TBlock& block) override;
-
-    static IAllocator* Instance() noexcept;
-};