internal/concepts.hpp
- View this file on GitHub
- Last update: 2024-05-10 22:51:41+09:00
- Include:
#include "internal/concepts.hpp"
Required by
- action/base.hpp
- action/helpers.hpp
- action/null.hpp
- action/range_add.hpp
- action/range_add_range_max.hpp
- action/range_add_range_min.hpp
- action/range_add_range_sum.hpp
- action/range_affine_range_minmax.hpp
- action/range_affine_range_sum.hpp
- action/range_bitxor.hpp
- action/range_chgcd_range_gcd.hpp
- action/range_chmax_range_max.hpp
- action/range_chmin_range_min.hpp
- action/range_chminchmax_range_minmax.hpp
- action/range_composition.hpp
- action/range_flip_range_bitxor.hpp
- action/range_gcd.hpp
- action/range_max.hpp
- action/range_min.hpp
- action/range_sequence_hash.hpp
- action/range_set.hpp
- action/range_set_range_composition.hpp
- action/range_set_range_max.hpp
- action/range_set_range_min.hpp
- action/range_set_range_sum.hpp
- action/range_sum.hpp
- adaptor/array.hpp
- adaptor/internal/advanced_container.hpp
- adaptor/internal/input.hpp
- adaptor/io.hpp
- adaptor/map.hpp
- adaptor/multi_container.hpp
- adaptor/set.hpp
- adaptor/string.hpp
- adaptor/valarray.hpp
- adaptor/vector.hpp
- algebraic/addition.hpp
- algebraic/affine.hpp
- algebraic/assignment.hpp
- algebraic/base.hpp
- algebraic/bit_and.hpp
- algebraic/bit_or.hpp
- algebraic/bit_xor.hpp
- algebraic/combined.hpp
- algebraic/gcd.hpp
- algebraic/helper.hpp
- algebraic/internal/concepts.hpp
- algebraic/maximum.hpp
- algebraic/minimum.hpp
- algebraic/minmax.hpp
- algebraic/null.hpp
- algebraic/opposite.hpp
- algebraic/rolling_hash.hpp
- convolution/gcd.hpp
- convolution/internal/butterfly.hpp
- convolution/lcm.hpp
- convolution/sum.hpp
- data_structure/adaptor/set.hpp
- data_structure/bit_vector.hpp
- data_structure/disjoint_set.hpp
- data_structure/disjoint_sparse_table.hpp
- data_structure/dynamic_segment_tree.hpp
- data_structure/dynamic_sequence.hpp
- data_structure/dynamic_set.hpp
- data_structure/fenwick_tree.hpp
- data_structure/foldable_deque.hpp
- data_structure/foldable_queue.hpp
- data_structure/foldable_stack.hpp
- data_structure/internal/basic_tree_concept.hpp
- data_structure/internal/dynamic_tree.hpp
- data_structure/internal/tree_dumper.hpp
- data_structure/lazy_segment_tree.hpp
- data_structure/persistent_queue.hpp
- data_structure/red_black_tree.hpp
- data_structure/segment_tree.hpp
- data_structure/treap.hpp
- data_structure/wavelet_matrix.hpp
- debugger/debug.hpp
debugger/test.cpp
- geometry/arrow.hpp
- geometry/circle.hpp
- geometry/convex_hull.hpp
- geometry/line.hpp
- geometry/point.hpp
- geometry/polygon.hpp
- geometry/segment.hpp
- geometry/triangle.hpp
- graph/centroid_decomposition.hpp
- graph/centroid_path_decomposition.hpp
- graph/connected_components.hpp
- graph/internal/01bfs.hpp
- graph/internal/bfs.hpp
- graph/internal/dijkstra.hpp
- graph/is_bipartite.hpp
- graph/lowest_common_ancestor.hpp
- graph/manhattan_minimum_spanning_tree.hpp
- graph/maximum_bipartite_matching.hpp
- graph/minimum_paph_cover.hpp
- graph/parse_grid.hpp
- graph/reachability_test.hpp
- graph/shortest_path.hpp
- graph/spanning_tree.hpp
- graph/topological_sort.hpp
- graph/tree_diamiter.hpp
- graph/tree_hash.hpp
- hash/general_hasher.hpp
- hash/multiset_hasher.hpp
- hash/sequence_hasher.hpp
- hash/set_hasher.hpp
- include/actions.hpp
- include/adaptors.hpp
- include/algebraic.hpp
- include/all.hpp
- include/convolutions.hpp
- include/data_structures.hpp
- include/geometries.hpp
- include/graph_theory.hpp
- include/hashes.hpp
- include/iterable.hpp
- include/numeric.hpp
- include/template.hpp
- include/views.hpp
- internal/auto_holder.hpp
- iterable/accumulation.hpp
- iterable/adjacent_difference.hpp
- iterable/applied.hpp
- iterable/compressed.hpp
- iterable/count_inversion.hpp
- iterable/counter.hpp
- iterable/inverse.hpp
- iterable/longest_common_subsequence.hpp
- iterable/longest_increasing_subsequence.hpp
- iterable/operation.hpp
- iterable/run_length_encoding.hpp
- iterable/z_array.hpp
- numeric/arithmetic.hpp
- numeric/binomial_coefficient.hpp
- numeric/bit.hpp
- numeric/divisor_multiple_transform.hpp
- numeric/divisors.hpp
- numeric/factorial.hpp
- numeric/fast_prime.hpp
- numeric/float.hpp
- numeric/internal/divisors.hpp
- numeric/internal/factorize.hpp
- numeric/internal/mo.hpp
- numeric/internal/mod.hpp
- numeric/internal/number_base.hpp
- numeric/internal/primality_test.hpp
- numeric/internal/primitive_root.hpp
- numeric/interval_scanner.hpp
- numeric/leveler.hpp
- numeric/matrix.hpp
- numeric/modular/barrett_reduction.hpp
- numeric/modular/binary_reduction.hpp
- numeric/modular/builtin_reduction.hpp
- numeric/modular/modint.hpp
- numeric/modular/modint_interface.hpp
- numeric/modular/montgomery_reduction.hpp
- numeric/numerical_sequence.hpp
- numeric/prime_counter.hpp
- numeric/prime_enumerator.hpp
- numeric/prime_sieve.hpp
- numeric/quotient_enumerator.hpp
- numeric/repeater.hpp
- numeric/stern_brocot_tree.hpp
- numeric/subset_enumerator.hpp
- random/engine.hpp
- structure/graph.hpp
- structure/grid.hpp
- template/debug.hpp
- template/standard.hpp
- template/using.hpp
- utility/functional.hpp
- utility/restrictor.hpp
- verify/aizu-online-judge/itp1_1_a/internal/dynamic_sequence.0000.hpp
- verify/aizu-online-judge/itp1_1_a/internal/dynamic_sequence.0001.hpp
- view/chunk.hpp
- view/cyclic.hpp
- view/repeat.hpp
- view/slide.hpp
- view/stride.hpp
- view/zip.hpp
Verified with
- verify/aizu-online-judge/0342/0000.test.cpp
- verify/aizu-online-judge/1508/0000.test.cpp
- verify/aizu-online-judge/1508/0001.test.cpp
- verify/aizu-online-judge/1508/0002.test.cpp
- verify/aizu-online-judge/1549/0000.test.cpp
- verify/aizu-online-judge/1549/0001.test.cpp
- verify/aizu-online-judge/1549/0002.test.cpp
- verify/aizu-online-judge/1549/0003.test.cpp
- verify/aizu-online-judge/2320/0000.test.cpp
- verify/aizu-online-judge/2426/0000.test.cpp
- verify/aizu-online-judge/alds1_10_c/0000.test.cpp
- verify/aizu-online-judge/alds1_11_d/0000.test.cpp
- verify/aizu-online-judge/alds1_11_d/0001.test.cpp
- verify/aizu-online-judge/alds1_14_b/0000.test.cpp
- verify/aizu-online-judge/cgl_1_a/0000.test.cpp
- verify/aizu-online-judge/cgl_1_b/0000.test.cpp
- verify/aizu-online-judge/cgl_1_c/0000.test.cpp
- verify/aizu-online-judge/cgl_2_a/0000.test.cpp
- verify/aizu-online-judge/cgl_2_b/0000.test.cpp
- verify/aizu-online-judge/cgl_2_c/0000.test.cpp
- verify/aizu-online-judge/cgl_3_a/0000.test.cpp
- verify/aizu-online-judge/cgl_3_b/0000.test.cpp
- verify/aizu-online-judge/cgl_4_a/0000.test.cpp
- verify/aizu-online-judge/cgl_7_a/0000.test.cpp
- verify/aizu-online-judge/cgl_7_b/0000.test.cpp
- verify/aizu-online-judge/cgl_7_c/0000.test.cpp
- verify/aizu-online-judge/dsl_1_a/0000.test.cpp
- verify/aizu-online-judge/dsl_2_a/0000.test.cpp
- verify/aizu-online-judge/dsl_2_d/0000.test.cpp
- verify/aizu-online-judge/dsl_2_d/0001.test.cpp
- verify/aizu-online-judge/dsl_2_d/0002.test.cpp
- verify/aizu-online-judge/dsl_2_d/0003.test.cpp
- verify/aizu-online-judge/dsl_2_d/0004.test.cpp
- verify/aizu-online-judge/dsl_2_d/0005.test.cpp
- verify/aizu-online-judge/dsl_2_d/0006.test.cpp
- verify/aizu-online-judge/dsl_2_d/0007.test.cpp
- verify/aizu-online-judge/dsl_2_d/0008.test.cpp
- verify/aizu-online-judge/dsl_2_d/0009.test.cpp
- verify/aizu-online-judge/dsl_2_e/0000.test.cpp
- verify/aizu-online-judge/dsl_2_e/0001.test.cpp
- verify/aizu-online-judge/dsl_2_f/0000.test.cpp
- verify/aizu-online-judge/dsl_2_f/0001.test.cpp
- verify/aizu-online-judge/dsl_2_f/0002.test.cpp
- verify/aizu-online-judge/dsl_2_f/0003.test.cpp
- verify/aizu-online-judge/dsl_2_f/0004.test.cpp
- verify/aizu-online-judge/dsl_2_f/0005.test.cpp
- verify/aizu-online-judge/dsl_2_g/0000.test.cpp
- verify/aizu-online-judge/dsl_2_g/0001.test.cpp
- verify/aizu-online-judge/dsl_2_g/0002.test.cpp
- verify/aizu-online-judge/dsl_2_g/0003.test.cpp
- verify/aizu-online-judge/dsl_2_h/0000.test.cpp
- verify/aizu-online-judge/dsl_2_h/0001.test.cpp
- verify/aizu-online-judge/dsl_2_h/0002.test.cpp
- verify/aizu-online-judge/dsl_2_h/0003.test.cpp
- verify/aizu-online-judge/dsl_2_h/0004.test.cpp
- verify/aizu-online-judge/dsl_2_i/0000.test.cpp
- verify/aizu-online-judge/grl_1_a/0000.test.cpp
- verify/aizu-online-judge/itp1_1_a/0000.test.cpp
- verify/aizu-online-judge/itp1_1_a/0001.test.cpp
- verify/aizu-online-judge/itp1_1_a/0002.test.cpp
- verify/aizu-online-judge/itp1_1_a/0003.test.cpp
- verify/aizu-online-judge/itp1_1_a/0004.test.cpp
- verify/aizu-online-judge/itp1_1_a/0005.test.cpp
- verify/aizu-online-judge/itp1_1_a/0006.test.cpp
- verify/aizu-online-judge/itp1_1_a/0007.test.cpp
- verify/aizu-online-judge/itp1_1_a/0008.test.cpp
- verify/aizu-online-judge/itp1_1_a/0009.test.cpp
- verify/aizu-online-judge/itp1_1_a/0010.test.cpp
- verify/aizu-online-judge/itp1_1_a/0011.test.cpp
- verify/aizu-online-judge/itp1_1_a/0012.test.cpp
- verify/aizu-online-judge/itp1_1_a/0013.test.cpp
- verify/aizu-online-judge/itp1_1_a/0014.test.cpp
- verify/aizu-online-judge/itp1_1_a/0015.test.cpp
- verify/aizu-online-judge/itp1_6_c/0000.test.cpp
- verify/aizu-online-judge/ntl_1_a/0000.test.cpp
- verify/yosupo-judge/associative_array/0000.test.cpp
- verify/yosupo-judge/associative_array/0001.test.cpp
- verify/yosupo-judge/associative_array/0002.test.cpp
- verify/yosupo-judge/associative_array/0003.test.cpp
- verify/yosupo-judge/binomial_coefficient/0000.test.cpp
- verify/yosupo-judge/binomial_coefficient_prime_mod/0000.test.cpp
- verify/yosupo-judge/binomial_coefficient_prime_mod/0001.test.cpp
- verify/yosupo-judge/binomial_coefficient_prime_mod/0002.test.cpp
- verify/yosupo-judge/binomial_coefficient_prime_mod/0003.test.cpp
- verify/yosupo-judge/bipartitematching/0000.test.cpp
- verify/yosupo-judge/convolution_mod/0000.test.cpp
- verify/yosupo-judge/convolution_mod_1000000007/0000.test.cpp
- verify/yosupo-judge/counting_primes/0000.test.cpp
- verify/yosupo-judge/deque_operate_all_composite/0000.test.cpp
- verify/yosupo-judge/deque_operate_all_composite/0001.test.cpp
- verify/yosupo-judge/deque_operate_all_composite/0002.test.cpp
- verify/yosupo-judge/deque_operate_all_composite/0003.test.cpp
- verify/yosupo-judge/deque_operate_all_composite/0004.test.cpp
- verify/yosupo-judge/deque_operate_all_composite/0005.test.cpp
- verify/yosupo-judge/double_ended_priority_queue/0000.test.cpp
- verify/yosupo-judge/dynamic_sequence_range_affine_range_sum/0000.test.cpp
- verify/yosupo-judge/dynamic_sequence_range_affine_range_sum/0001.test.cpp
- verify/yosupo-judge/dynamic_sequence_range_affine_range_sum/0002.test.cpp
- verify/yosupo-judge/dynamic_sequence_range_affine_range_sum/0003.test.cpp
- verify/yosupo-judge/dynamic_sequence_range_affine_range_sum/0004.test.cpp
- verify/yosupo-judge/dynamic_sequence_range_affine_range_sum/0005.test.cpp
- verify/yosupo-judge/enumerate_primes/0000.test.cpp
- verify/yosupo-judge/enumerate_quotients/0000.test.cpp
- verify/yosupo-judge/factorize/0000.test.cpp
- verify/yosupo-judge/gcd_convolution/0000.test.cpp
- verify/yosupo-judge/kth_root_integer/0000.test.cpp
- verify/yosupo-judge/lca/0000.test.cpp
- verify/yosupo-judge/lca/0001.test.cpp
- verify/yosupo-judge/lcm_convolution/0000.test.cpp
- verify/yosupo-judge/longest_increasing_subsequence/0000.test.cpp
- verify/yosupo-judge/manhattanmst/0000.test.cpp
- verify/yosupo-judge/many_aplusb_128bit/0000.test.cpp
- verify/yosupo-judge/matrix_det_arbitrary_mod/0000.test.cpp
- verify/yosupo-judge/matrix_det_arbitrary_mod/0001.test.cpp
- verify/yosupo-judge/matrix_product/0000.test.cpp
- verify/yosupo-judge/matrix_product/0001.test.cpp
- verify/yosupo-judge/matrix_product/0002.test.cpp
- verify/yosupo-judge/matrix_product/0003.test.cpp
- verify/yosupo-judge/matrix_product/0004.test.cpp
- verify/yosupo-judge/matrix_product/0005.test.cpp
- verify/yosupo-judge/matrix_product/0006.test.cpp
- verify/yosupo-judge/matrix_product/0007.test.cpp
- verify/yosupo-judge/matrix_product/0008.test.cpp
- verify/yosupo-judge/matrix_product/0009.test.cpp
- verify/yosupo-judge/matrix_product/0010.test.cpp
- verify/yosupo-judge/matrix_product/0011.test.cpp
- verify/yosupo-judge/matrix_product/0012.test.cpp
- verify/yosupo-judge/matrix_product/0013.test.cpp
- verify/yosupo-judge/matrix_product/0014.test.cpp
- verify/yosupo-judge/matrix_product/0015.test.cpp
- verify/yosupo-judge/persistent_queue/0000.test.cpp
- verify/yosupo-judge/point_add_range_sum/0000.test.cpp
- verify/yosupo-judge/point_add_range_sum/0001.test.cpp
- verify/yosupo-judge/point_add_range_sum/0002.test.cpp
- verify/yosupo-judge/point_add_range_sum/0003.test.cpp
- verify/yosupo-judge/point_add_range_sum/0004.test.cpp
- verify/yosupo-judge/point_set_range_composite/0000.test.cpp
- verify/yosupo-judge/point_set_range_composite/0001.test.cpp
- verify/yosupo-judge/point_set_range_composite/0002.test.cpp
- verify/yosupo-judge/point_set_range_composite/0003.test.cpp
- verify/yosupo-judge/predecessor_problem/0000.test.cpp
- verify/yosupo-judge/predecessor_problem/0001.test.cpp
- verify/yosupo-judge/predecessor_problem/0002.test.cpp
- verify/yosupo-judge/predecessor_problem/0003.test.cpp
- verify/yosupo-judge/primality_test/0000.test.cpp
- verify/yosupo-judge/primitive_root/0000.test.cpp
- verify/yosupo-judge/queue_operate_all_composite/0000.test.cpp
- verify/yosupo-judge/queue_operate_all_composite/0001.test.cpp
- verify/yosupo-judge/queue_operate_all_composite/0002.test.cpp
- verify/yosupo-judge/queue_operate_all_composite/0003.test.cpp
- verify/yosupo-judge/queue_operate_all_composite/0004.test.cpp
- verify/yosupo-judge/queue_operate_all_composite/0005.test.cpp
- verify/yosupo-judge/range_affine_range_sum/0000.test.cpp
- verify/yosupo-judge/range_affine_range_sum/0001.test.cpp
- verify/yosupo-judge/range_affine_range_sum/0002.test.cpp
- verify/yosupo-judge/range_affine_range_sum/0003.test.cpp
- verify/yosupo-judge/range_affine_range_sum/0004.test.cpp
- verify/yosupo-judge/range_affine_range_sum/0005.test.cpp
- verify/yosupo-judge/range_affine_range_sum/0006.test.cpp
- verify/yosupo-judge/range_affine_range_sum/0007.test.cpp
- verify/yosupo-judge/range_affine_range_sum/0008.test.cpp
- verify/yosupo-judge/range_kth_smallest/0000.test.cpp
- verify/yosupo-judge/range_kth_smallest/0001.test.cpp
- verify/yosupo-judge/range_kth_smallest/0002.test.cpp
- verify/yosupo-judge/range_kth_smallest/0003.test.cpp
- verify/yosupo-judge/range_reverse_range_sum/0000.test.cpp
- verify/yosupo-judge/rectangle_sum/0000.test.cpp
- verify/yosupo-judge/rectangle_sum/0001.test.cpp
- verify/yosupo-judge/shortest_path/0000.test.cpp
- verify/yosupo-judge/shortest_path/0001.test.cpp
- verify/yosupo-judge/shortest_path/0002.test.cpp
- verify/yosupo-judge/static_range_frequency/0000.test.cpp
- verify/yosupo-judge/static_range_frequency/0001.test.cpp
- verify/yosupo-judge/static_range_sum/0000.test.cpp
- verify/yosupo-judge/static_range_sum/0001.test.cpp
- verify/yosupo-judge/static_range_sum/0002.test.cpp
- verify/yosupo-judge/static_range_sum/0003.test.cpp
- verify/yosupo-judge/static_range_sum/0004.test.cpp
- verify/yosupo-judge/static_range_sum/0005.test.cpp
- verify/yosupo-judge/static_range_sum/0006.test.cpp
- verify/yosupo-judge/static_range_sum/0007.test.cpp
- verify/yosupo-judge/static_range_sum/0008.test.cpp
- verify/yosupo-judge/staticrmq/0000.test.cpp
- verify/yosupo-judge/staticrmq/0001.test.cpp
- verify/yosupo-judge/staticrmq/0002.test.cpp
- verify/yosupo-judge/staticrmq/0003.test.cpp
- verify/yosupo-judge/system_of_linear_equations/0000.test.cpp
- verify/yukicoder/649/0000.test.cpp
- verify/yukicoder/738/0000.test.cpp
- verify/yukicoder/789/0000.test.cpp
- verify/yukicoder/789/0001.test.cpp
Code
#pragma once
#include <type_traits>
#include <concepts>
#include <ranges>
#include <limits>
#include <functional>
namespace uni {
namespace internal {
template<class R, class T>
concept convertibel_range = std::convertible_to<std::ranges::range_value_t<R>, T>;
template<class T, class V>
concept item_or_convertible_range = std::convertible_to<T, V> || convertibel_range<T, V>;
template<class Structure>
concept available =
requires () {
typename Structure;
};
template<
template<class...> class Structure,
class... TemplateParameters
>
concept available_with = available<Structure<TemplateParameters...>>;
template<class T> concept arithmetic = std::is_arithmetic_v<T>;
template<class T> concept pointer = std::is_pointer_v<T>;
template<class T> concept structural = std::is_class_v<T>;
template<class Large, class Small>
concept has_double_digits_of = (std::numeric_limits<Large>::digits == 2 * std::numeric_limits<Small>::digits);
template<class Large, class Small>
concept has_more_digits_than = (std::numeric_limits<Large>::digits > std::numeric_limits<Small>::digits);
template<class Large, class Small>
concept has_or_more_digits_than = (std::numeric_limits<Large>::digits >= std::numeric_limits<Small>::digits);
template<class T>
concept has_static_zero = requires { T::zero; };
template<class T>
concept has_static_one = requires { T::one; };
template<class L, class R = L>
concept weakly_bitand_calcurable = requires (L lhs, R rhs) { lhs & rhs; };
template<class L, class R = L>
concept weakly_bitor_calcurable = requires (L lhs, R rhs) { lhs | rhs; };
template<class L, class R = L>
concept weakly_bitxor_calcurable = requires (L lhs, R rhs) { lhs ^ rhs; };
template<class L, class R = L>
concept weakly_addable = requires (L lhs, R rhs) { lhs + rhs; };
template<class L, class R = L>
concept weakly_subtractable = requires (L lhs, R rhs) { lhs - rhs; };
template<class L, class R = L>
concept weakly_multipliable = requires (L lhs, R rhs) { lhs * rhs; };
template<class L, class R = L>
concept weakly_divisable = requires (L lhs, R rhs) { lhs / rhs; };
template<class L, class R = L>
concept weakly_remainder_calculable = requires (L lhs, R rhs) { lhs % rhs; };
template<class L, class R = L>
concept weakly_bitand_assignable = requires (L lhs, R rhs) { lhs += rhs; };
template<class L, class R = L>
concept weakly_bitor_assignable = requires (L lhs, R rhs) { lhs |= rhs; };
template<class L, class R = L>
concept weakly_bitxor_assignable = requires (L lhs, R rhs) { lhs ^= rhs; };
template<class L, class R = L>
concept weakly_addition_assignable = requires (L lhs, R rhs) { lhs += rhs; };
template<class L, class R = L>
concept weakly_subtraction_assignable = requires (L lhs, R rhs) { lhs -= rhs; };
template<class L, class R = L>
concept weakly_multipliation_assignalbe = requires (L lhs, R rhs) { lhs *= rhs; };
template<class L, class R = L>
concept weakly_division_assignable = requires (L lhs, R rhs) { lhs /= rhs; };
template<class L, class R = L>
concept weakly_remainder_assignable = requires (L lhs, R rhs) { lhs /= rhs; };
template<class L, class R = L>
concept bitand_calculable =
weakly_bitand_calcurable<L, R> &&
weakly_bitand_calcurable<std::invoke_result_t<std::bit_and<>&, L, R>, R> &&
weakly_bitand_calcurable<L, std::invoke_result_t<std::bit_and<>&, L, R>> &&
weakly_bitand_calcurable<std::invoke_result_t<std::bit_and<>&, L, R>, std::invoke_result_t<std::bit_and<>&, L, R>>;
template<class L, class R = L>
concept bitor_calculable =
weakly_bitor_calcurable<L, R> &&
weakly_bitor_calcurable<std::invoke_result_t<std::bit_or<>&, L, R>, R> &&
weakly_bitor_calcurable<L, std::invoke_result_t<std::bit_or<>&, L, R>> &&
weakly_bitor_calcurable<std::invoke_result_t<std::bit_or<>&, L, R>, std::invoke_result_t<std::bit_or<>&, L, R>>;
template<class L, class R = L>
concept bitxor_calculable =
weakly_bitxor_calcurable<L, R> &&
weakly_bitxor_calcurable<std::invoke_result_t<std::bit_xor<>&, L, R>, R> &&
weakly_bitxor_calcurable<L, std::invoke_result_t<std::bit_xor<>&, L, R>> &&
weakly_bitxor_calcurable<std::invoke_result_t<std::bit_xor<>&, L, R>, std::invoke_result_t<std::bit_xor<>&, L, R>>;
template<class L, class R = L>
concept addable =
weakly_addable<L, R> &&
weakly_addable<std::invoke_result_t<std::plus<>&, L, R>, R> &&
weakly_addable<L, std::invoke_result_t<std::plus<>&, L, R>> &&
weakly_addable<std::invoke_result_t<std::plus<>&, L, R>, std::invoke_result_t<std::plus<>&, L, R>>;
template<class L, class R = L>
concept subtractable =
weakly_subtractable<L, R> &&
weakly_subtractable<std::invoke_result_t<std::minus<>&, L, R>, R> &&
weakly_subtractable<L, std::invoke_result_t<std::minus<>&, L, R>> &&
weakly_subtractable<std::invoke_result_t<std::minus<>&, L, R>, std::invoke_result_t<std::minus<>&, L, R>>;
template<class L, class R = L>
concept multipliable =
weakly_multipliable<L, R> &&
weakly_multipliable<std::invoke_result_t<std::multiplies<>&, L, R>, R> &&
weakly_multipliable<L, std::invoke_result_t<std::multiplies<>&, L, R>> &&
weakly_multipliable<std::invoke_result_t<std::multiplies<>&, L, R>, std::invoke_result_t<std::multiplies<>&, L, R>>;
template<class L, class R = L>
concept divisable =
weakly_divisable<L, R> &&
weakly_divisable<std::invoke_result_t<std::divides<>&, L, R>, R> &&
weakly_divisable<L, std::invoke_result_t<std::divides<>&, L, R>> &&
weakly_divisable<std::invoke_result_t<std::divides<>&, L, R>, std::invoke_result_t<std::divides<>&, L, R>>;
template<class L, class R = L>
concept remainder_calculable =
weakly_remainder_calculable<L, R> &&
weakly_remainder_calculable<std::invoke_result_t<std::modulus<>&, L, R>, R> &&
weakly_remainder_calculable<L, std::invoke_result_t<std::modulus<>&, L, R>> &&
weakly_remainder_calculable<std::invoke_result_t<std::modulus<>&, L, R>, std::invoke_result_t<std::modulus<>&, L, R>>;
template<class L, class R = L>
concept bitand_assignable =
weakly_bitand_assignable<L, R> &&
weakly_bitand_assignable<std::invoke_result_t<std::bit_and<>&, L, R>, R> &&
weakly_bitand_assignable<L, std::invoke_result_t<std::bit_and<>&, L, R>> &&
weakly_bitand_assignable<std::invoke_result_t<std::bit_and<>&, L, R>, std::invoke_result_t<std::bit_and<>&, L, R>>;
template<class L, class R = L>
concept bitor_assignable =
weakly_bitor_calcurable<L, R> &&
weakly_bitor_calcurable<std::invoke_result_t<std::bit_or<>&, L, R>, R> &&
weakly_bitor_calcurable<L, std::invoke_result_t<std::bit_or<>&, L, R>> &&
weakly_bitor_calcurable<std::invoke_result_t<std::bit_or<>&, L, R>, std::invoke_result_t<std::bit_or<>&, L, R>>;
template<class L, class R = L>
concept bitxor_assignable =
weakly_bitxor_calcurable<L, R> &&
weakly_bitxor_calcurable<std::invoke_result_t<std::bit_xor<>&, L, R>, R> &&
weakly_bitxor_calcurable<L, std::invoke_result_t<std::bit_xor<>&, L, R>> &&
weakly_bitxor_calcurable<std::invoke_result_t<std::bit_xor<>&, L, R>, std::invoke_result_t<std::bit_xor<>&, L, R>>;
template<class L, class R = L>
concept addition_assignable =
weakly_addition_assignable<L, R> &&
weakly_addition_assignable<std::remove_cvref_t<std::invoke_result_t<std::plus<>&, L, R>>, R> &&
weakly_addition_assignable<L, std::invoke_result_t<std::plus<>&, L, R>> &&
weakly_addition_assignable<std::remove_cvref_t<std::invoke_result_t<std::plus<>&, L, R>>, std::invoke_result_t<std::plus<>&, L, R>>;
template<class L, class R = L>
concept subtraction_assignable =
weakly_subtraction_assignable<L, R> &&
weakly_subtraction_assignable<std::remove_cvref_t<std::invoke_result_t<std::minus<>&, L, R>>, R> &&
weakly_subtraction_assignable<L, std::invoke_result_t<std::minus<>&, L, R>> &&
weakly_subtraction_assignable<std::remove_cvref_t<std::invoke_result_t<std::minus<>&, L, R>>, std::invoke_result_t<std::minus<>&, L, R>>;
template<class L, class R = L>
concept multipliation_assignalbe =
weakly_multipliation_assignalbe<L, R> &&
weakly_multipliation_assignalbe<std::remove_cvref_t<std::invoke_result_t<std::multiplies<>&, L, R>>, R> &&
weakly_multipliation_assignalbe<L, std::invoke_result_t<std::multiplies<>&, L, R>> &&
weakly_multipliation_assignalbe<std::remove_cvref_t<std::invoke_result_t<std::multiplies<>&, L, R>>, std::invoke_result_t<std::multiplies<>&, L, R>>;
template<class L, class R = L>
concept division_assignable =
weakly_division_assignable<L, R> &&
weakly_division_assignable<std::remove_cvref_t<std::invoke_result_t<std::divides<>&, L, R>>, R> &&
weakly_division_assignable<L, std::invoke_result_t<std::divides<>&, L, R>> &&
weakly_division_assignable<std::remove_cvref_t<std::invoke_result_t<std::divides<>&, L, R>>, std::invoke_result_t<std::divides<>&, L, R>>;
template<class L, class R = L>
concept remainder_assignable =
weakly_remainder_assignable<L, R> &&
weakly_remainder_assignable<std::remove_cvref_t<std::invoke_result_t<std::modulus<>&, L, R>>, R> &&
weakly_remainder_assignable<L, std::invoke_result_t<std::modulus<>&, L, R>> &&
weakly_remainder_assignable<std::remove_cvref_t<std::invoke_result_t<std::modulus<>&, L, R>>, std::invoke_result_t<std::modulus<>&, L, R>>;
template<class T>
concept weakly_incrementable =
std::movable<T> &&
requires (T v) {
{ ++v } -> std::same_as<T&>;
v++;
};
template<class T>
concept weakly_decrementable =
std::movable<T> &&
requires (T v) {
{ --v } -> std::same_as<T&>;
v--;
};
template<class T>
concept incrementable =
std::regular<T> &&
weakly_incrementable<T> &&
requires (T v) {
{ v++ } -> std::same_as<T>;
};
template<class T>
concept decrementable =
std::regular<T> &&
weakly_decrementable<T> &&
requires (T v) {
{ v-- } -> std::same_as<T>;
};
template<class L, class R = L>
concept weakly_arithmetic_operable =
weakly_addable<L, R> &&
weakly_subtractable<L, R> &&
weakly_multipliable<L, R> &&
weakly_divisable<L, R>;
template<class L, class R = L>
concept weakly_arithmetic_operation_assignable =
weakly_addition_assignable<L, R> &&
weakly_subtraction_assignable<L, R> &&
weakly_multipliation_assignalbe<L, R> &&
weakly_division_assignable<L, R>;
template<class L, class R = L>
concept arithmetic_operable =
weakly_arithmetic_operable<L, R> &&
addable<L, R> &&
subtractable<L, R> &&
multipliable<L, R> &&
divisable<L, R>;
template<class L, class R = L>
concept arithmetic_operation_assignable =
weakly_arithmetic_operation_assignable<L, R> &&
addition_assignable<L, R> &&
subtraction_assignable<L, R> &&
multipliation_assignalbe<L, R> &&
division_assignable<L, R>;
template<class T>
concept unary_addable =
requires (T v) {
{ +v } -> std::same_as<T>;
};
template<class T>
concept unary_subtractable =
requires (T v) {
{ -v } -> std::same_as<T>;
};
template<class T>
concept numeric =
std::regular<T> &&
arithmetic_operable<T> &&
arithmetic_operation_assignable<T> &&
weakly_incrementable<T> &&
unary_addable<T> &&
unary_subtractable<T>;
} // namespace internal
} // namespace uni#line 2 "internal/concepts.hpp"
#include <type_traits>
#include <concepts>
#include <ranges>
#include <limits>
#include <functional>
namespace uni {
namespace internal {
template<class R, class T>
concept convertibel_range = std::convertible_to<std::ranges::range_value_t<R>, T>;
template<class T, class V>
concept item_or_convertible_range = std::convertible_to<T, V> || convertibel_range<T, V>;
template<class Structure>
concept available =
requires () {
typename Structure;
};
template<
template<class...> class Structure,
class... TemplateParameters
>
concept available_with = available<Structure<TemplateParameters...>>;
template<class T> concept arithmetic = std::is_arithmetic_v<T>;
template<class T> concept pointer = std::is_pointer_v<T>;
template<class T> concept structural = std::is_class_v<T>;
template<class Large, class Small>
concept has_double_digits_of = (std::numeric_limits<Large>::digits == 2 * std::numeric_limits<Small>::digits);
template<class Large, class Small>
concept has_more_digits_than = (std::numeric_limits<Large>::digits > std::numeric_limits<Small>::digits);
template<class Large, class Small>
concept has_or_more_digits_than = (std::numeric_limits<Large>::digits >= std::numeric_limits<Small>::digits);
template<class T>
concept has_static_zero = requires { T::zero; };
template<class T>
concept has_static_one = requires { T::one; };
template<class L, class R = L>
concept weakly_bitand_calcurable = requires (L lhs, R rhs) { lhs & rhs; };
template<class L, class R = L>
concept weakly_bitor_calcurable = requires (L lhs, R rhs) { lhs | rhs; };
template<class L, class R = L>
concept weakly_bitxor_calcurable = requires (L lhs, R rhs) { lhs ^ rhs; };
template<class L, class R = L>
concept weakly_addable = requires (L lhs, R rhs) { lhs + rhs; };
template<class L, class R = L>
concept weakly_subtractable = requires (L lhs, R rhs) { lhs - rhs; };
template<class L, class R = L>
concept weakly_multipliable = requires (L lhs, R rhs) { lhs * rhs; };
template<class L, class R = L>
concept weakly_divisable = requires (L lhs, R rhs) { lhs / rhs; };
template<class L, class R = L>
concept weakly_remainder_calculable = requires (L lhs, R rhs) { lhs % rhs; };
template<class L, class R = L>
concept weakly_bitand_assignable = requires (L lhs, R rhs) { lhs += rhs; };
template<class L, class R = L>
concept weakly_bitor_assignable = requires (L lhs, R rhs) { lhs |= rhs; };
template<class L, class R = L>
concept weakly_bitxor_assignable = requires (L lhs, R rhs) { lhs ^= rhs; };
template<class L, class R = L>
concept weakly_addition_assignable = requires (L lhs, R rhs) { lhs += rhs; };
template<class L, class R = L>
concept weakly_subtraction_assignable = requires (L lhs, R rhs) { lhs -= rhs; };
template<class L, class R = L>
concept weakly_multipliation_assignalbe = requires (L lhs, R rhs) { lhs *= rhs; };
template<class L, class R = L>
concept weakly_division_assignable = requires (L lhs, R rhs) { lhs /= rhs; };
template<class L, class R = L>
concept weakly_remainder_assignable = requires (L lhs, R rhs) { lhs /= rhs; };
template<class L, class R = L>
concept bitand_calculable =
weakly_bitand_calcurable<L, R> &&
weakly_bitand_calcurable<std::invoke_result_t<std::bit_and<>&, L, R>, R> &&
weakly_bitand_calcurable<L, std::invoke_result_t<std::bit_and<>&, L, R>> &&
weakly_bitand_calcurable<std::invoke_result_t<std::bit_and<>&, L, R>, std::invoke_result_t<std::bit_and<>&, L, R>>;
template<class L, class R = L>
concept bitor_calculable =
weakly_bitor_calcurable<L, R> &&
weakly_bitor_calcurable<std::invoke_result_t<std::bit_or<>&, L, R>, R> &&
weakly_bitor_calcurable<L, std::invoke_result_t<std::bit_or<>&, L, R>> &&
weakly_bitor_calcurable<std::invoke_result_t<std::bit_or<>&, L, R>, std::invoke_result_t<std::bit_or<>&, L, R>>;
template<class L, class R = L>
concept bitxor_calculable =
weakly_bitxor_calcurable<L, R> &&
weakly_bitxor_calcurable<std::invoke_result_t<std::bit_xor<>&, L, R>, R> &&
weakly_bitxor_calcurable<L, std::invoke_result_t<std::bit_xor<>&, L, R>> &&
weakly_bitxor_calcurable<std::invoke_result_t<std::bit_xor<>&, L, R>, std::invoke_result_t<std::bit_xor<>&, L, R>>;
template<class L, class R = L>
concept addable =
weakly_addable<L, R> &&
weakly_addable<std::invoke_result_t<std::plus<>&, L, R>, R> &&
weakly_addable<L, std::invoke_result_t<std::plus<>&, L, R>> &&
weakly_addable<std::invoke_result_t<std::plus<>&, L, R>, std::invoke_result_t<std::plus<>&, L, R>>;
template<class L, class R = L>
concept subtractable =
weakly_subtractable<L, R> &&
weakly_subtractable<std::invoke_result_t<std::minus<>&, L, R>, R> &&
weakly_subtractable<L, std::invoke_result_t<std::minus<>&, L, R>> &&
weakly_subtractable<std::invoke_result_t<std::minus<>&, L, R>, std::invoke_result_t<std::minus<>&, L, R>>;
template<class L, class R = L>
concept multipliable =
weakly_multipliable<L, R> &&
weakly_multipliable<std::invoke_result_t<std::multiplies<>&, L, R>, R> &&
weakly_multipliable<L, std::invoke_result_t<std::multiplies<>&, L, R>> &&
weakly_multipliable<std::invoke_result_t<std::multiplies<>&, L, R>, std::invoke_result_t<std::multiplies<>&, L, R>>;
template<class L, class R = L>
concept divisable =
weakly_divisable<L, R> &&
weakly_divisable<std::invoke_result_t<std::divides<>&, L, R>, R> &&
weakly_divisable<L, std::invoke_result_t<std::divides<>&, L, R>> &&
weakly_divisable<std::invoke_result_t<std::divides<>&, L, R>, std::invoke_result_t<std::divides<>&, L, R>>;
template<class L, class R = L>
concept remainder_calculable =
weakly_remainder_calculable<L, R> &&
weakly_remainder_calculable<std::invoke_result_t<std::modulus<>&, L, R>, R> &&
weakly_remainder_calculable<L, std::invoke_result_t<std::modulus<>&, L, R>> &&
weakly_remainder_calculable<std::invoke_result_t<std::modulus<>&, L, R>, std::invoke_result_t<std::modulus<>&, L, R>>;
template<class L, class R = L>
concept bitand_assignable =
weakly_bitand_assignable<L, R> &&
weakly_bitand_assignable<std::invoke_result_t<std::bit_and<>&, L, R>, R> &&
weakly_bitand_assignable<L, std::invoke_result_t<std::bit_and<>&, L, R>> &&
weakly_bitand_assignable<std::invoke_result_t<std::bit_and<>&, L, R>, std::invoke_result_t<std::bit_and<>&, L, R>>;
template<class L, class R = L>
concept bitor_assignable =
weakly_bitor_calcurable<L, R> &&
weakly_bitor_calcurable<std::invoke_result_t<std::bit_or<>&, L, R>, R> &&
weakly_bitor_calcurable<L, std::invoke_result_t<std::bit_or<>&, L, R>> &&
weakly_bitor_calcurable<std::invoke_result_t<std::bit_or<>&, L, R>, std::invoke_result_t<std::bit_or<>&, L, R>>;
template<class L, class R = L>
concept bitxor_assignable =
weakly_bitxor_calcurable<L, R> &&
weakly_bitxor_calcurable<std::invoke_result_t<std::bit_xor<>&, L, R>, R> &&
weakly_bitxor_calcurable<L, std::invoke_result_t<std::bit_xor<>&, L, R>> &&
weakly_bitxor_calcurable<std::invoke_result_t<std::bit_xor<>&, L, R>, std::invoke_result_t<std::bit_xor<>&, L, R>>;
template<class L, class R = L>
concept addition_assignable =
weakly_addition_assignable<L, R> &&
weakly_addition_assignable<std::remove_cvref_t<std::invoke_result_t<std::plus<>&, L, R>>, R> &&
weakly_addition_assignable<L, std::invoke_result_t<std::plus<>&, L, R>> &&
weakly_addition_assignable<std::remove_cvref_t<std::invoke_result_t<std::plus<>&, L, R>>, std::invoke_result_t<std::plus<>&, L, R>>;
template<class L, class R = L>
concept subtraction_assignable =
weakly_subtraction_assignable<L, R> &&
weakly_subtraction_assignable<std::remove_cvref_t<std::invoke_result_t<std::minus<>&, L, R>>, R> &&
weakly_subtraction_assignable<L, std::invoke_result_t<std::minus<>&, L, R>> &&
weakly_subtraction_assignable<std::remove_cvref_t<std::invoke_result_t<std::minus<>&, L, R>>, std::invoke_result_t<std::minus<>&, L, R>>;
template<class L, class R = L>
concept multipliation_assignalbe =
weakly_multipliation_assignalbe<L, R> &&
weakly_multipliation_assignalbe<std::remove_cvref_t<std::invoke_result_t<std::multiplies<>&, L, R>>, R> &&
weakly_multipliation_assignalbe<L, std::invoke_result_t<std::multiplies<>&, L, R>> &&
weakly_multipliation_assignalbe<std::remove_cvref_t<std::invoke_result_t<std::multiplies<>&, L, R>>, std::invoke_result_t<std::multiplies<>&, L, R>>;
template<class L, class R = L>
concept division_assignable =
weakly_division_assignable<L, R> &&
weakly_division_assignable<std::remove_cvref_t<std::invoke_result_t<std::divides<>&, L, R>>, R> &&
weakly_division_assignable<L, std::invoke_result_t<std::divides<>&, L, R>> &&
weakly_division_assignable<std::remove_cvref_t<std::invoke_result_t<std::divides<>&, L, R>>, std::invoke_result_t<std::divides<>&, L, R>>;
template<class L, class R = L>
concept remainder_assignable =
weakly_remainder_assignable<L, R> &&
weakly_remainder_assignable<std::remove_cvref_t<std::invoke_result_t<std::modulus<>&, L, R>>, R> &&
weakly_remainder_assignable<L, std::invoke_result_t<std::modulus<>&, L, R>> &&
weakly_remainder_assignable<std::remove_cvref_t<std::invoke_result_t<std::modulus<>&, L, R>>, std::invoke_result_t<std::modulus<>&, L, R>>;
template<class T>
concept weakly_incrementable =
std::movable<T> &&
requires (T v) {
{ ++v } -> std::same_as<T&>;
v++;
};
template<class T>
concept weakly_decrementable =
std::movable<T> &&
requires (T v) {
{ --v } -> std::same_as<T&>;
v--;
};
template<class T>
concept incrementable =
std::regular<T> &&
weakly_incrementable<T> &&
requires (T v) {
{ v++ } -> std::same_as<T>;
};
template<class T>
concept decrementable =
std::regular<T> &&
weakly_decrementable<T> &&
requires (T v) {
{ v-- } -> std::same_as<T>;
};
template<class L, class R = L>
concept weakly_arithmetic_operable =
weakly_addable<L, R> &&
weakly_subtractable<L, R> &&
weakly_multipliable<L, R> &&
weakly_divisable<L, R>;
template<class L, class R = L>
concept weakly_arithmetic_operation_assignable =
weakly_addition_assignable<L, R> &&
weakly_subtraction_assignable<L, R> &&
weakly_multipliation_assignalbe<L, R> &&
weakly_division_assignable<L, R>;
template<class L, class R = L>
concept arithmetic_operable =
weakly_arithmetic_operable<L, R> &&
addable<L, R> &&
subtractable<L, R> &&
multipliable<L, R> &&
divisable<L, R>;
template<class L, class R = L>
concept arithmetic_operation_assignable =
weakly_arithmetic_operation_assignable<L, R> &&
addition_assignable<L, R> &&
subtraction_assignable<L, R> &&
multipliation_assignalbe<L, R> &&
division_assignable<L, R>;
template<class T>
concept unary_addable =
requires (T v) {
{ +v } -> std::same_as<T>;
};
template<class T>
concept unary_subtractable =
requires (T v) {
{ -v } -> std::same_as<T>;
};
template<class T>
concept numeric =
std::regular<T> &&
arithmetic_operable<T> &&
arithmetic_operation_assignable<T> &&
weakly_incrementable<T> &&
unary_addable<T> &&
unary_subtractable<T>;
} // namespace internal
} // namespace uni