123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229 |
- /*
- * Frozen
- * Copyright 2016 QuarksLab
- *
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
- #ifndef FROZEN_LETITGO_BITS_ALGORITHMS_H
- #define FROZEN_LETITGO_BITS_ALGORITHMS_H
-
- #include "frozen/bits/basic_types.h"
-
- #include <limits>
- #include <tuple>
-
- namespace frozen {
-
- namespace bits {
-
- auto constexpr next_highest_power_of_two(std::size_t v) {
- // https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
- constexpr auto trip_count = std::numeric_limits<decltype(v)>::digits;
- v--;
- for(std::size_t i = 1; i < trip_count; i <<= 1)
- v |= v >> i;
- v++;
- return v;
- }
-
- template<class T>
- auto constexpr log(T v) {
- std::size_t n = 0;
- while (v > 1) {
- n += 1;
- v >>= 1;
- }
- return n;
- }
-
- constexpr std::size_t bit_weight(std::size_t n) {
- return (n <= 8*sizeof(unsigned int))
- + (n <= 8*sizeof(unsigned long))
- + (n <= 8*sizeof(unsigned long long))
- + (n <= 128);
- }
-
- unsigned int select_uint_least(std::integral_constant<std::size_t, 4>);
- unsigned long select_uint_least(std::integral_constant<std::size_t, 3>);
- unsigned long long select_uint_least(std::integral_constant<std::size_t, 2>);
- template<std::size_t N>
- unsigned long long select_uint_least(std::integral_constant<std::size_t, N>) {
- static_assert(N < 2, "unsupported type size");
- return {};
- }
-
-
- template<std::size_t N>
- using select_uint_least_t = decltype(select_uint_least(std::integral_constant<std::size_t, bit_weight(N)>()));
-
- template <typename Iter, typename Compare>
- constexpr auto min_element(Iter begin, const Iter end,
- Compare const &compare) {
- auto result = begin;
- while (begin != end) {
- if (compare(*begin, *result)) {
- result = begin;
- }
- ++begin;
- }
- return result;
- }
-
- template <class T>
- constexpr void cswap(T &a, T &b) {
- auto tmp = a;
- a = b;
- b = tmp;
- }
-
- template <class T, class U>
- constexpr void cswap(std::pair<T, U> & a, std::pair<T, U> & b) {
- cswap(a.first, b.first);
- cswap(a.second, b.second);
- }
-
- template <class... Tys, std::size_t... Is>
- constexpr void cswap(std::tuple<Tys...> &a, std::tuple<Tys...> &b, std::index_sequence<Is...>) {
- using swallow = int[];
- (void) swallow{(cswap(std::get<Is>(a), std::get<Is>(b)), 0)...};
- }
-
- template <class... Tys>
- constexpr void cswap(std::tuple<Tys...> &a, std::tuple<Tys...> &b) {
- cswap(a, b, std::make_index_sequence<sizeof...(Tys)>());
- }
-
- template <typename Iterator, class Compare>
- constexpr Iterator partition(Iterator left, Iterator right, Compare const &compare) {
- auto pivot = left + (right - left) / 2;
- auto value = *pivot;
- cswap(*right, *pivot);
- for (auto it = left; 0 < right - it; ++it) {
- if (compare(*it, value)) {
- cswap(*it, *left);
- left++;
- }
- }
- cswap(*right, *left);
- return left;
- }
-
- template <typename Iterator, class Compare>
- constexpr void quicksort(Iterator left, Iterator right, Compare const &compare) {
- while (0 < right - left) {
- auto new_pivot = bits::partition(left, right, compare);
- quicksort(left, new_pivot, compare);
- left = new_pivot + 1;
- }
- }
-
- template <typename T, std::size_t N, class Compare>
- constexpr bits::carray<T, N> quicksort(bits::carray<T, N> const &array,
- Compare const &compare) {
- bits::carray<T, N> res = array;
- quicksort(res.begin(), res.end() - 1, compare);
- return res;
- }
-
- template <class T, class Compare> struct LowerBound {
- T const &value_;
- Compare const &compare_;
- constexpr LowerBound(T const &value, Compare const &compare)
- : value_(value), compare_(compare) {}
-
- template <class ForwardIt>
- inline constexpr ForwardIt doit_fast(ForwardIt first,
- std::integral_constant<std::size_t, 0>) {
- return first;
- }
-
- template <class ForwardIt, std::size_t N>
- inline constexpr ForwardIt doit_fast(ForwardIt first,
- std::integral_constant<std::size_t, N>) {
- auto constexpr step = N / 2;
- static_assert(N/2 == N - N / 2 - 1, "power of two minus 1");
- auto it = first + step;
- auto next_it = compare_(*it, value_) ? it + 1 : first;
- return doit_fast(next_it, std::integral_constant<std::size_t, N / 2>{});
- }
-
- template <class ForwardIt, std::size_t N>
- inline constexpr ForwardIt doitfirst(ForwardIt first, std::integral_constant<std::size_t, N>, std::integral_constant<bool, true>) {
- return doit_fast(first, std::integral_constant<std::size_t, N>{});
- }
-
- template <class ForwardIt, std::size_t N>
- inline constexpr ForwardIt doitfirst(ForwardIt first, std::integral_constant<std::size_t, N>, std::integral_constant<bool, false>) {
- auto constexpr next_power = next_highest_power_of_two(N);
- auto constexpr next_start = next_power / 2 - 1;
- auto it = first + next_start;
- if (compare_(*it, value_)) {
- auto constexpr next = N - next_start - 1;
- return doitfirst(it + 1, std::integral_constant<std::size_t, next>{}, std::integral_constant<bool, next_highest_power_of_two(next) - 1 == next>{});
- }
- else
- return doit_fast(first, std::integral_constant<std::size_t, next_start>{});
- }
-
- template <class ForwardIt>
- inline constexpr ForwardIt doitfirst(ForwardIt first, std::integral_constant<std::size_t, 1>, std::integral_constant<bool, false>) {
- return doit_fast(first, std::integral_constant<std::size_t, 1>{});
- }
- };
-
- template <std::size_t N, class ForwardIt, class T, class Compare>
- constexpr ForwardIt lower_bound(ForwardIt first, const T &value, Compare const &compare) {
- return LowerBound<T, Compare>{value, compare}.doitfirst(first, std::integral_constant<std::size_t, N>{}, std::integral_constant<bool, next_highest_power_of_two(N) - 1 == N>{});
- }
-
- template <std::size_t N, class Compare, class ForwardIt, class T>
- constexpr bool binary_search(ForwardIt first, const T &value,
- Compare const &compare) {
- ForwardIt where = lower_bound<N>(first, value, compare);
- return (!(where == first + N) && !(compare(value, *where)));
- }
-
-
- template<class InputIt1, class InputIt2>
- constexpr bool equal(InputIt1 first1, InputIt1 last1, InputIt2 first2)
- {
- for (; first1 != last1; ++first1, ++first2) {
- if (!(*first1 == *first2)) {
- return false;
- }
- }
- return true;
- }
-
- template<class InputIt1, class InputIt2>
- constexpr bool lexicographical_compare(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2)
- {
- for (; (first1 != last1) && (first2 != last2); ++first1, ++first2) {
- if (*first1 < *first2)
- return true;
- if (*first2 < *first1)
- return false;
- }
- return (first1 == last1) && (first2 != last2);
- }
-
- } // namespace bits
- } // namespace frozen
-
- #endif
|