CppUtil

mean

template<typename It>
inline double mean(It begin, It end)

median

template<typename It>
double median(It begin, It end)

variance

template<typename It>
inline double variance(It begin, It end)

standard_deviation

template<typename It>
inline double standard_deviation(It begin, It end)

max_subarray_sum

template<typename It>
max_subarray_result<It> max_subarray_sum(It begin, It end)

template<typename It>
struct max_subarray_result
{
	It begin;
	It end;
	typename It::value_type sum;
};

matrix

template<typename T>
class matrix

explicit matrix(std::size_t m, std::size_t n)

template<typename Type, size_t M, size_t N>
explicit matrix(const Type(&mtx)[M][N]): m(M), n(N)

row_holder operator[](std::size_t idx)

const_row_holder operator[](std::size_t idx) const

T determinant() const

Longest common subsequence

template<typename RndIt1, typename RndIt2>
std::vector<RndIt1> longest_common_subsequence(RndIt1 first1, RndIt1 last1, RndIt2 first2, RndIt2 last2)

Longest common substring

template<typename RndIt1, typename RndIt2>
std::pair<RndIt1> longest_common_substring(RndIt1 first1, RndIt1 last1, RndIt2 first2, RndIt2 last2)

Longest palindrome subsequence

template<typename RndIt>
std::vector<RndIt> longest_palindrome_subsequence(RndIt first, RndIt last)

thread_pool

class thread_pool

---

explicit thread_pool(size_t t = std::thread::hardware_concurrency())

template<typename Fn, typename ...Args>
void schedule(Fn fn, Args ...args)

 void schedule(task_package& p)

bool is_busy()

uint64_t executed_tasks() const

uint64_t size() const

uint64_t queue_length() const

void release()

void join()

~thread_pool()

parallel_map

template<typename Container>
class parallel_map

---

explicit parallel_map(Container& target, thread_pool& pool): target(&target), pool(&pool) {}

template<typename Fn, typename ...Args>
parallel_map& map(Fn fn, Args ...args)

void run()

void wrun()

task_package

class task_package

---

template<typename Fn, typename ...Args>
void append(Fn fn, Args ...args)

void wait()

bool completed() const

timer

class timer

---

void start()

uint64_t stop()

uint64_t reset()

formaters

template<typename Fn, 
		 typename... Args, 
		 typename = std::enable_if_t<has_return_type<Fn, Args...>::value>>
auto timing(const char *msg, std::ostream &os, Fn &&fn, Args &&... args)

template<typename Fn,
         typename... Args,
         typename = std::enable_if_t<std::negation_v<std::bool_constant<has_return_type<Fn, Args...>::value>>>>
void timing(const char *msg, std::ostream &os, Fn &&fn, Args &&... args)

print memory

void print_memory(const char* mem, size_t size, std::ostream& os, const PrintOptions& opt = { 16, true, true, '.' })

struct PrintOptions
{
	size_t width;
	bool title;
	bool ascii;
	char no_ascii_placeholder;
};

random_iterator

class random_iterator

---

template<typename ...Args>
explicit random_iterator(Args... args)

random_iterator& operator++()

random_iterator operator++(int)

const T& operator*()

random_string

template<typename T>
class random_string

---

explicit random_string(const T& dict)

T operator()(size_t length)

static random_string hex();

static random_string digits();

static random_string alphabet();

utf8_iterator

template<typename Iterator>
class utf8_iterator

---

utf8_iterator(Iterator it) : it(it) {}

utf8_iterator& operator++()

char32_t operator*()

bool operator!=(Iterator r) const

levenshtein_distance

template<typename It>
uint64_t levenshtein_distance(It first1, It last1, It first2, It last2, levenshtein_costs const &costs = {1, 1, 1})

IO overloads for containers

template<typename Container, typename T = typename Container::value_type>
std::istream& operator>>(std::istream& is, Container& x)

template<typename Container, typename T = typename Container::value_type>
std::ostream& operator<<(std::ostream& os, const Container& x)

queue

template<typename T>
class queue

template<typename V>
void push(V &&val)

void pop()

T const &front() const

T &front()

T &back()

T const &back() const

bool empty() const

fixed_queue

template<typename T, size_t N>
class fixed_queue

bool enqueue(const T& value)

T dequeue()

inline bool empty() const

inline bool full() const

inline size_t capacity() const

inline size_t size() const

threadsafe_queue

template<typename T>
class threadsafe_queue

---

void push(const T& val)

T pop()

std::optional<T> try_pop()

bool empty() const

size_t size() const

threadsafe_priority_queue

template<typename T>
class threadsafe_priority_queue

---

void push(const T& val)

T pop()

std::optional<T> try_pop()

T& top()

bool empty() const

size_t size() const

merge

template<typename It1, typename It2, typename D>
void merge(It1 first1, It1 last1, It2 first2, It2 last2, D dest)

sort::merge

template<typename It>
void merge(It first, It last)

lomuto_partition

template<typename It>
It lomuto_partition(It first, It second, It pivot)

quick_select

template<typename It, typename P = std::function<It(It, It, It)>>
void quick_select(It first, It second, size_t k, P partition = &lomuto_partition<It>)

literals

template<typename T, typename Unit>
class prefixed_value

template<typename To, typename T, typename U>
constexpr To prefixed_value_cast(prefixed_value<T, U> const &value)

template<typename T1, typename U1, typename T2, typename U2>
constexpr bool operator==(prefixed_value<T1, U1> const &l, prefixed_value<T2, U2> const &r)

template<typename T1, typename U1, typename T2, typename U2>
constexpr bool operator!=(prefixed_value<T1, U1> const &l, prefixed_value<T2, U2> const &r)

template<typename T1, typename U1, typename T2, typename U2>
constexpr std::common_type_t<prefixed_value<T1, U1>, prefixed_value<T2, U2>> operator+(prefixed_value<T1, U1> const &l,
                                                                                       prefixed_value<T2, U2> const &r)

template<typename T1, typename U1, typename T2, typename U2>
constexpr std::common_type_t<prefixed_value<T1, U1>, prefixed_value<T2, U2>> operator-(prefixed_value<T1, U1> const &l,
                                                                                       prefixed_value<T2, U2> const &r)

template<typename T1, typename U1, typename T2, typename U2>
constexpr std::common_type_t<prefixed_value<T1, U1>, prefixed_value<T2, U2>> operator*(prefixed_value<T1, U1> const &l,
                                                                                       prefixed_value<T2, U2> const &r)

template<typename T1, typename U1, typename T2, typename U2>
constexpr std::common_type_t<prefixed_value<T1, U1>, prefixed_value<T2, U2>> operator/(prefixed_value<T1, U1> const &l,
                                                                                       prefixed_value<T2, U2> const &r)

distance_literals

template<typename T, typename Unit>
class distance : public literals::prefixed_value<T, Unit>

template<typename T>
using km = distance<T, literals::unit<1000.l>>

template<typename T>
using m = distance<T, literals::unit<1.l>>

template<typename T>
using cm = distance<T, literals::unit<0.01l>>

template<typename T>
using mm = distance<T, literals::unit<0.001l>>

template<typename T>
using mile = distance<T, literals::unit<1609.344l>>

km<int64_t> operator""_km(unsigned long long x)

m<int64_t> operator""_m(unsigned long long x)

cm<int64_t> operator""_cm(unsigned long long x)

mm<int64_t> operator""_mm(unsigned long long x)

mile<int64_t> operator""_mile(unsigned long long x)

km<long double> operator""_km(long double x)

m<long double> operator""_m(long double x)

cm<long double> operator""_cm(long double x)

mm<long double> operator""_mm(long double x)

mile<long double> operator""_mile(long double x)