catboost 1.25.1 → 1.27.0

package/inc/util/digest/numeric.h

@@ -1,86 +0,0 @@
-#pragma once
-
-#include <util/generic/typelist.h>
-#include <util/system/defaults.h>
-
-/*
- * original url (now dead): http://www.cris.com/~Ttwang/tech/inthash.htm
- * copy: https://gist.github.com/badboy/6267743
- */
-
-static constexpr ui8 IntHashImpl(ui8 key8) noexcept {
-    size_t key = key8;
-
-    key += ~(key << 15);
-    key ^= (key >> 10);
-    key += (key << 3);
-    key ^= (key >> 6);
-    key += ~(key << 11);
-    key ^= (key >> 16);
-
-    return static_cast<ui8>(key);
-}
-
-static constexpr ui16 IntHashImpl(ui16 key16) noexcept {
-    size_t key = key16;
-
-    key += ~(key << 15);
-    key ^= (key >> 10);
-    key += (key << 3);
-    key ^= (key >> 6);
-    key += ~(key << 11);
-    key ^= (key >> 16);
-
-    return static_cast<ui16>(key);
-}
-
-static constexpr ui32 IntHashImpl(ui32 key) noexcept {
-    key += ~(key << 15);
-    key ^= (key >> 10);
-    key += (key << 3);
-    key ^= (key >> 6);
-    key += ~(key << 11);
-    key ^= (key >> 16);
-
-    return key;
-}
-
-static constexpr ui64 IntHashImpl(ui64 key) noexcept {
-    key += ~(key << 32);
-    key ^= (key >> 22);
-    key += ~(key << 13);
-    key ^= (key >> 8);
-    key += (key << 3);
-    key ^= (key >> 15);
-    key += ~(key << 27);
-    key ^= (key >> 31);
-
-    return key;
-}
-
-template <class T>
-static constexpr T IntHash(T t) noexcept {
-    using TCvt = TFixedWidthUnsignedInt<T>;
-
-    return IntHashImpl((TCvt)(t));
-}
-
-/*
- * can handle floats && pointers
- */
-template <class T>
-static constexpr size_t NumericHash(T t) noexcept {
-    using TCvt = TFixedWidthUnsignedInt<T>;
-
-    union Y_HIDDEN {
-        T t;
-        TCvt cvt;
-    } u{t};
-
-    return (size_t)IntHash(u.cvt);
-}
-
-template <class T>
-static constexpr T CombineHashes(T l, T r) noexcept {
-    return IntHash(l) ^ r;
-}

package/inc/util/digest/sequence.h

@@ -1,48 +0,0 @@
-#pragma once
-
-#include "numeric.h"
-#include <util/generic/hash.h>
-#include <util/generic/array_ref.h>
-
-template <typename ElementHash = void>
-class TRangeHash {
-private:
-    template <typename ElementType>
-    using TBase = std::conditional_t<
-        !std::is_void<ElementHash>::value,
-        ElementHash,
-        THash<ElementType>>;
-
-public:
-    template <typename Range>
-    size_t operator()(const Range& range) const {
-        size_t accumulated = 0;
-        for (const auto& element : range) {
-            accumulated = CombineHashes(accumulated, TBase<typename Range::value_type>()(element));
-        }
-        return accumulated;
-    }
-};
-
-using TSimpleRangeHash = TRangeHash<>;
-
-template <typename RegionHash = void>
-class TContiguousHash {
-private:
-    template <typename ElementType>
-    using TBase = std::conditional_t<
-        !std::is_void<RegionHash>::value,
-        RegionHash,
-        TRangeHash<ElementType>>;
-
-public:
-    template <typename ContainerType>
-    auto operator()(const ContainerType& container) const {
-        return operator()(MakeArrayRef(container));
-    }
-
-    template <typename ElementType>
-    auto operator()(const TArrayRef<ElementType>& data) const {
-        return TBase<ElementType>()(data);
-    }
-};

package/inc/util/draft/date.h

@@ -1,129 +0,0 @@
-#pragma once
-
-#include <util/stream/output.h>
-#include <util/stream/input.h>
-#include <util/generic/string.h>
-#include <util/datetime/constants.h>
-
-#include <ctime>
-
-// XXX: uses system calls for trivial things. may be very slow therefore.
-
-time_t GetDateStart(time_t ts);
-
-// Local date (without time zone)
-class TDate {
-    // XXX: wrong: must store number of days since epoch
-    time_t Timestamp;
-
-public:
-    TDate()
-        : Timestamp(0)
-    {
-    }
-
-    // XXX: wrong. Should be replace with two methods: TodayGmt() and TodayLocal()
-    static TDate Today() {
-        return TDate(time(nullptr));
-    }
-
-    TDate(const char* yyyymmdd);
-    TDate(const TString& yyyymmdd);
-    TDate(unsigned year, unsigned month, unsigned monthDay); // month from 01, monthDay from 01
-    TDate(const TString& date, const TString& format);
-
-    explicit TDate(time_t t);
-
-    time_t GetStart() const {
-        return Timestamp;
-    }
-
-    time_t GetStartUTC() const;
-
-    TString ToStroka(const char* format = "%Y%m%d") const;
-
-    TDate& operator++() {
-        Timestamp = GetDateStart(Timestamp + 3 * (SECONDS_IN_DAY / 2));
-        return *this;
-    }
-
-    TDate& operator--() {
-        Timestamp = GetDateStart(Timestamp - SECONDS_IN_DAY / 2);
-        return *this;
-    }
-
-    TDate& operator+=(unsigned days) {
-        Timestamp = GetDateStart(Timestamp + days * SECONDS_IN_DAY + SECONDS_IN_DAY / 2);
-        return *this;
-    }
-
-    TDate& operator-=(unsigned days) {
-        Timestamp = GetDateStart(Timestamp - days * SECONDS_IN_DAY + SECONDS_IN_DAY / 2);
-        return *this;
-    }
-
-    TDate operator+(unsigned days) const {
-        return TDate(Timestamp + days * SECONDS_IN_DAY + SECONDS_IN_DAY / 2);
-    }
-
-    TDate operator-(unsigned days) const {
-        return TDate(Timestamp - days * SECONDS_IN_DAY + SECONDS_IN_DAY / 2);
-    }
-
-    unsigned GetWeekDay() const; // days since Sunday
-
-    unsigned GetYear() const;
-    unsigned GetMonth() const;    // from 01
-    unsigned GetMonthDay() const; // from 01
-
-    friend bool operator<(const TDate& left, const TDate& right);
-    friend bool operator>(const TDate& left, const TDate& right);
-    friend bool operator<=(const TDate& left, const TDate& right);
-    friend bool operator>=(const TDate& left, const TDate& right);
-    friend bool operator==(const TDate& left, const TDate& right);
-    friend int operator-(const TDate& left, const TDate& right);
-
-    friend IInputStream& operator>>(IInputStream& left, TDate& right);
-    friend IOutputStream& operator<<(IOutputStream& left, const TDate& right);
-};
-
-Y_DECLARE_PODTYPE(TDate);
-
-inline bool operator<(const TDate& left, const TDate& right) {
-    return left.Timestamp < right.Timestamp;
-}
-
-inline bool operator>(const TDate& left, const TDate& right) {
-    return left.Timestamp > right.Timestamp;
-}
-
-inline bool operator<=(const TDate& left, const TDate& right) {
-    return left.Timestamp <= right.Timestamp;
-}
-
-inline bool operator>=(const TDate& left, const TDate& right) {
-    return left.Timestamp >= right.Timestamp;
-}
-
-inline bool operator==(const TDate& left, const TDate& right) {
-    return left.Timestamp == right.Timestamp;
-}
-
-inline int operator-(const TDate& left, const TDate& right) {
-    if (left < right) {
-        return -(right - left);
-    }
-    return static_cast<int>((left.Timestamp + SECONDS_IN_DAY / 2 - right.Timestamp) / SECONDS_IN_DAY);
-}
-
-inline IInputStream& operator>>(IInputStream& left, TDate& right) {
-    TString stroka;
-    left >> stroka;
-    TDate date(stroka.c_str());
-    right = date;
-    return left;
-}
-
-inline IOutputStream& operator<<(IOutputStream& left, const TDate& right) {
-    return left << right.ToStroka();
-}

package/inc/util/draft/datetime.h

@@ -1,184 +0,0 @@
-#pragma once
-
-#include <util/generic/algorithm.h>
-#include <util/generic/string.h>
-#include <util/generic/yexception.h>
-#include <util/generic/ymath.h>
-#include <util/datetime/base.h>
-
-#include <cstdlib>
-
-#include <time.h>
-
-namespace NDatetime {
-    extern const ui32 MonthDays[2][12];        // !leapYear; !!leapYear
-    extern const ui32 MonthDaysNewYear[2][13]; // !leapYear; !!leapYear
-
-    inline ui32 YearDaysAD(ui32 year) {
-        year = Max<ui32>(year, 1) - 1; //1 AD comes straight after 1 BC, no 0 AD
-        return year * 365 + year / 4 - year / 100 + year / 400;
-    }
-
-    inline bool LeapYearAD(ui32 year) {
-        return (!(year % 4) && (year % 100)) || !(year % 400);
-    }
-
-    inline ui32 YDayFromMonthAndDay(ui32 month /*0 - based*/, ui32 mday /*1 - based*/, bool isleap) {
-        return MonthDaysNewYear[isleap][Min(month, (ui32)11u)] + mday - 1;
-    }
-
-    void YDayToMonthAndDay(ui32 yday /*0 - based*/, bool isleap, ui32* month /*0 - based*/, ui32* mday /*1 - based*/);
-
-    struct TSimpleTM {
-        enum EField {
-            F_NONE = 0,
-            F_SEC,
-            F_MIN,
-            F_HOUR,
-            F_DAY,
-            F_MON,
-            F_YEAR
-        };
-
-        i32 GMTOff = 0; // -43200 - 50400 seconds
-        ui16 Year = 0;  // from 1900
-        ui16 YDay = 0;  // 0-365
-        ui8 Mon = 0;    // 0-11
-        ui8 MDay = 0;   // 1-31
-        ui8 WDay = 0;   // 0-6
-        ui8 Hour = 0;   // 0-23
-        ui8 Min = 0;    // 0-59
-        ui8 Sec = 0;    // 0-60 - doesn't care for leap seconds. Most of the time it's ok.
-        i8 IsDst = 0;   // -1/0/1
-        bool IsLeap = false;
-
-    public:
-        static TSimpleTM New(time_t t = 0, i32 gmtoff = 0, i8 isdst = 0);
-        static TSimpleTM NewLocal(time_t = 0);
-
-        static TSimpleTM New(const struct tm&);
-
-        static TSimpleTM CurrentUTC();
-
-        TSimpleTM() = default;
-
-        TSimpleTM(ui32 year, ui32 mon, ui32 day, ui32 h = 0, ui32 m = 0, ui32 s = 0) {
-            Zero(*this);
-            SetRealDate(year, mon, day, h, m, s);
-        }
-
-        // keeps the object consistent
-        TSimpleTM& Add(EField f, i32 amount = 1);
-
-        TString ToString(const char* fmt = "%a, %d %b %Y %H:%M:%S %z") const;
-
-        TSimpleTM& ToUTC() {
-            return *this = New(AsTimeT());
-        }
-
-        bool IsUTC() const {
-            return !IsDst && !GMTOff;
-        }
-
-        time_t AsTimeT() const;
-
-        operator time_t() const {
-            return AsTimeT();
-        };
-
-        struct tm AsStructTmLocal() const;
-
-        struct tm AsStructTmUTC() const;
-
-        operator struct tm() const {
-            return AsStructTmLocal();
-        }
-
-        ui32 RealYear() const {
-            return ui32(Year + 1900);
-        }
-
-        ui32 RealMonth() const {
-            return ui32(Mon + 1);
-        }
-
-        TSimpleTM& SetRealDate(ui32 year, ui32 mon, ui32 mday, ui32 hour = -1, ui32 min = -1, ui32 sec = -1, i32 isdst = 0);
-
-        // regenerates all fields from Year, MDay, Hour, Min, Sec, IsDst, GMTOffset
-        TSimpleTM& RegenerateFields();
-
-        friend bool operator==(const TSimpleTM& a, const TSimpleTM& b) {
-            return a.AsTimeT() == b.AsTimeT();
-        }
-
-        friend bool operator==(const TSimpleTM& s, const struct tm& t) {
-            return s == New(t);
-        }
-
-        friend bool operator==(const struct tm& t, const TSimpleTM& s) {
-            return s == t;
-        }
-
-        friend bool operator!=(const TSimpleTM& a, const TSimpleTM& b) {
-            return !(a == b);
-        }
-
-        friend bool operator!=(const TSimpleTM& s, const struct tm& t) {
-            return !(s == t);
-        }
-
-        friend bool operator!=(const struct tm& t, const TSimpleTM& s) {
-            return s != t;
-        }
-    };
-}
-
-inline TString date2str(const time_t date) {
-    struct tm dateTm;
-    memset(&dateTm, 0, sizeof(dateTm));
-    localtime_r(&date, &dateTm);
-    char buf[9];
-    strftime(buf, sizeof(buf), "%Y%m%d", &dateTm);
-    return TString(buf);
-}
-
-inline time_t str2date(const TString& dateStr) {
-    struct tm dateTm;
-    memset(&dateTm, 0, sizeof(tm));
-    strptime(dateStr.data(), "%Y%m%d", &dateTm);
-    return mktime(&dateTm);
-}
-
-// checks whether time2 > time1 and close enough to it
-inline bool AreTimesSeqAndClose(time_t time1, time_t time2, time_t closeInterval = 10) {
-    return (time2 - time1) <= closeInterval;
-}
-
-// checks whether time2 and time1 are close enough
-inline bool AreTimesClose(time_t time1, time_t time2, time_t closeInterval = 10) {
-    return std::abs(time2 - time1) <= closeInterval;
-}
-
-////////////////////////////////
-
-struct TMonth {
-    ui16 Year;
-    ui8 Month;
-
-    TMonth(ui16 year = 0, ui8 month = 0)
-        : Year(year)
-        , Month(month)
-    {
-    }
-
-    TMonth operator-(ui16 n) {
-        if (n <= Month) {
-            return TMonth(Year, Month - (ui8)n);
-        } else {
-            n -= Month;
-            return (n % 12) ? TMonth(Year - 1 - (n / 12), 12 - (n % 12)) : TMonth(Year - (n / 12), 0);
-        }
-    }
-};
-
-Y_DECLARE_PODTYPE(NDatetime::TSimpleTM);

package/inc/util/draft/enum.h

@@ -1,136 +0,0 @@
-#pragma once
-
-#include <bitset>
-
-#include <util/generic/strbuf.h>
-#include <util/stream/str.h>
-#include <util/string/cast.h>
-#include <util/string/split.h>
-#include <utility>
-
-class TEnumNotFoundException: public yexception {
-};
-
-#define EnumFromString(key, entries) EnumFromStringImpl(key, entries, Y_ARRAY_SIZE(entries))
-#define EnumFromStringWithSize(key, entries, size) EnumFromStringImpl(key, entries, size)
-#define FindEnumFromString(key, entries) FindEnumFromStringImpl(key, entries, Y_ARRAY_SIZE(entries))
-#define FindEnumFromStringWithSize(key, entries, size) FindEnumFromStringImpl(key, entries, size)
-#define EnumToString(key, entries) EnumToStringImpl(key, entries, Y_ARRAY_SIZE(entries))
-#define EnumToStringWithSize(key, entries, size) EnumToStringImpl(key, entries, size)
-#define PrintEnumItems(entries) PrintEnumItemsImpl(entries, Y_ARRAY_SIZE(entries))
-
-template <class K1, class K2, class V>
-const V* FindEnumFromStringImpl(K1 key, const std::pair<K2, V>* entries, size_t arraySize) {
-    for (size_t i = 0; i < arraySize; i++)
-        if (entries[i].first == key)
-            return &entries[i].second;
-    return nullptr;
-}
-
-// special version for const char*
-template <class V>
-const V* FindEnumFromStringImpl(const char* key, const std::pair<const char*, V>* entries, size_t arraySize) {
-    for (size_t i = 0; i < arraySize; i++)
-        if (entries[i].first && key && !strcmp(entries[i].first, key))
-            return &entries[i].second;
-    return nullptr;
-}
-
-template <class K, class V>
-TString PrintEnumItemsImpl(const std::pair<K, V>* entries, size_t arraySize) {
-    TString result;
-    TStringOutput out(result);
-    for (size_t i = 0; i < arraySize; i++)
-        out << (i ? ", " : "") << "'" << entries[i].first << "'";
-    return result;
-}
-
-// special version for const char*
-template <class V>
-TString PrintEnumItemsImpl(const std::pair<const char*, V>* entries, size_t arraySize) {
-    TString result;
-    TStringOutput out(result);
-    for (size_t i = 0; i < arraySize; i++)
-        out << (i ? ", " : "") << "'" << (entries[i].first ? entries[i].first : "<null>") << "'";
-    return result;
-}
-
-template <class K1, class K2, class V>
-const V* EnumFromStringImpl(K1 key, const std::pair<K2, V>* entries, size_t arraySize) {
-    const V* res = FindEnumFromStringImpl(key, entries, arraySize);
-    if (res)
-        return res;
-
-    ythrow TEnumNotFoundException() << "Key '" << key << "' not found in enum. Valid options are: " << PrintEnumItemsImpl(entries, arraySize) << ". ";
-}
-
-template <class K, class V>
-const K* EnumToStringImpl(V value, const std::pair<K, V>* entries, size_t arraySize) {
-    for (size_t i = 0; i < arraySize; i++)
-        if (entries[i].second == value)
-            return &entries[i].first;
-
-    TEnumNotFoundException exc;
-    exc << "Value '" << int(value) << "' not found in enum. Valid values are: ";
-    for (size_t i = 0; i < arraySize; i++)
-        exc << (i ? ", " : "") << int(entries[i].second);
-    exc << ". ";
-    ythrow exc;
-}
-
-///////////////////////////////////
-
-template <class B>
-inline void SetEnumFlagsForEmptySpec(B& flags, bool allIfEmpty) {
-    if (allIfEmpty) {
-        flags.set();
-    } else {
-        flags.reset();
-    }
-}
-
-// all set by default
-template <class E, size_t N, size_t B>
-inline void SetEnumFlags(const std::pair<const char*, E> (&str2Enum)[N], TStringBuf optSpec,
-                         std::bitset<B>& flags, bool allIfEmpty = true) {
-    if (optSpec.empty()) {
-        SetEnumFlagsForEmptySpec(flags, allIfEmpty);
-    } else {
-        flags.reset();
-        for (const auto& it : StringSplitter(optSpec).Split(',')) {
-            E e = *EnumFromStringImpl(ToString(it.Token()).data(), str2Enum, N);
-            flags.set(e);
-        }
-    }
-}
-
-template <class E, size_t B>
-inline void SetEnumFlags(const std::pair<const char*, E>* str2Enum, TStringBuf optSpec,
-                         std::bitset<B>& flags, const size_t size,
-                         bool allIfEmpty = true) {
-    if (optSpec.empty()) {
-        SetEnumFlagsForEmptySpec(flags, allIfEmpty);
-    } else {
-        flags.reset();
-        for (const auto& it : StringSplitter(optSpec).Split(',')) {
-            E e = *EnumFromStringImpl(ToString(it.Token()).data(), str2Enum, size);
-            flags.set(e);
-        }
-    }
-}
-
-// for enums generated with GENERATE_ENUM_SERIALIZATION
-template <class E, size_t B>
-inline void SetEnumFlags(TStringBuf optSpec, std::bitset<B>& flags, bool allIfEmpty = true) {
-    if (optSpec.empty()) {
-        SetEnumFlagsForEmptySpec(flags, allIfEmpty);
-    } else {
-        flags.reset();
-        for (const auto& it : StringSplitter(optSpec).Split(',')) {
-            E e;
-            if (!TryFromString(it.Token(), e))
-                ythrow yexception() << "Unknown enum value '" << it.Token() << "'";
-            flags.set((size_t)e);
-        }
-    }
-}

package/inc/util/draft/holder_vector.h

@@ -1,102 +0,0 @@
-#pragma once
-
-#include <util/generic/ptr.h>
-#include <util/generic/vector.h>
-#include <util/generic/noncopyable.h>
-
-template <class T, class D = TDelete>
-class THolderVector: public TVector<T*>, public TNonCopyable {
-    using TBase = TVector<T*>;
-
-public:
-    explicit THolderVector(size_t n = 0)
-        : TBase(n)
-    {
-    }
-
-    ~THolderVector() {
-        Clear();
-    }
-
-    void Clear() {
-        for (typename TBase::iterator it = TBase::begin(); it != TBase::end(); ++it) {
-            if (*it)
-                D::Destroy(*it);
-        }
-        TBase::clear();
-    }
-
-    size_t Size() const {
-        return TBase::size();
-    }
-
-    // TVector takes ownership of T
-    void PushBack(T* t) {
-        try {
-            TBase::push_back(t);
-        } catch (...) {
-            if (t)
-                D::Destroy(t);
-            throw;
-        }
-    }
-
-    void PushBack(std::unique_ptr<T> t) {
-        PushBack(t.release());
-    }
-
-    void PushBack(THolder<T> t) {
-        PushBack(t.Release());
-    }
-
-    void Reset(size_t i, THolder<T> t) {
-        T* current = (*this)[i];
-        if (current) {
-            Y_ASSERT(current != t.Get());
-            D::Destroy(current);
-        }
-        (*this)[i] = t.Release();
-    }
-
-    void PopBack() {
-        if (size()) {
-            D::Destroy(back());
-            TBase::pop_back();
-        }
-    }
-
-    T* Release(size_t i) {
-        T* t = (*this)[i];
-        (*this)[i] = nullptr;
-        return t;
-    }
-
-    void Resize(size_t newSize) {
-        for (size_t i = newSize; i < size(); ++i) {
-            D::Destroy((*this)[i]);
-        }
-        TBase::resize(newSize);
-    }
-
-    void Swap(THolderVector& other) {
-        TBase::swap(other);
-    }
-
-    using TBase::operator[];
-    using TBase::operator bool;
-    using TBase::at;
-    using TBase::back;
-    using TBase::begin;
-    using TBase::capacity;
-    using TBase::empty;
-    using TBase::end;
-    using TBase::front;
-    using TBase::reserve;
-    using TBase::size;
-
-    using typename TBase::const_iterator;
-    using typename TBase::const_reverse_iterator;
-    using typename TBase::iterator;
-    using typename TBase::reverse_iterator;
-    using typename TBase::value_type;
-};