std::cmp_less_equal extended for my library (tools/cmp_less_equal.hpp)

• View this file on GitHub
• View document part on GitHub
• Last update: 2026-01-01 20:09:34+09:00
• Include: #include "tools/cmp_less_equal.hpp"

template <tools::integral T, tools::integral U>
constexpr bool cmp_less_equal(T t, U u) noexcept;

It is almost identical to std::cmp_less_equal, but compatible with user-defined extended integral types.

Constraints

• None

Time Complexity

• $O(1)$

License

• CC0

Author

• anqooqie

Depends on

• std::cmp_less extended for my library (tools/cmp_less.hpp)
• Concept for integral types including tools::int128_t and tools::uint128_t (tools/integral.hpp)
• std::is_integral extended for tools::int128_t and tools::uint128_t (tools/is_integral.hpp)
• std::is_signed extended for tools::int128_t and tools::uint128_t (tools/is_signed.hpp)
• std::make_unsigned extended for tools::int128_t and tools::uint128_t (tools/make_unsigned.hpp)

Required by

• Circular shift to the left / Rotate a given matrix 90 degrees to the left (tools/rotl.hpp)
• Circular shift to the right / Rotate a given matrix 90 degrees to the right (tools/rotr.hpp)
• Power of a sparse FPS (tools/sparse_fps_pow.hpp)
• Stern–Brocot tree (tools/stern_brocot_tree.hpp)

Verified with

• tests/cmp_less_equal.test.cpp
• tests/rotl.test.cpp
• tests/rotr.test.cpp
• tests/sparse_fps_pow/fraction.test.cpp
• tests/sparse_fps_pow/regular.test.cpp
• tests/stern_brocot_tree.test.cpp

Code

#ifndef TOOLS_CMP_LESS_EQUAL_HPP
#define TOOLS_CMP_LESS_EQUAL_HPP

#include "tools/cmp_less.hpp"
#include "tools/integral.hpp"

namespace tools {
  template <tools::integral T, tools::integral U>
  constexpr bool cmp_less_equal(const T t, const U u) noexcept {
    return !tools::cmp_less(u, t);
  }
}

#endif

#line 1 "tools/cmp_less_equal.hpp"



#line 1 "tools/cmp_less.hpp"



#line 1 "tools/integral.hpp"



#line 1 "tools/is_integral.hpp"



#include <type_traits>

namespace tools {
  template <typename T>
  struct is_integral : std::is_integral<T> {};

  template <typename T>
  inline constexpr bool is_integral_v = tools::is_integral<T>::value;
}


#line 5 "tools/integral.hpp"

namespace tools {
  template <typename T>
  concept integral = tools::is_integral_v<T>;
}


#line 1 "tools/is_signed.hpp"



#line 5 "tools/is_signed.hpp"

namespace tools {
  template <typename T>
  struct is_signed : std::is_signed<T> {};

  template <typename T>
  inline constexpr bool is_signed_v = tools::is_signed<T>::value;
}


#line 1 "tools/make_unsigned.hpp"



#line 5 "tools/make_unsigned.hpp"

namespace tools {
  template <typename T>
  struct make_unsigned : std::make_unsigned<T> {};

  template <typename T>
  using make_unsigned_t = typename tools::make_unsigned<T>::type;
}


#line 7 "tools/cmp_less.hpp"

namespace tools {
  template <tools::integral T, tools::integral U>
  constexpr bool cmp_less(const T t, const U u) noexcept {
    using UT = tools::make_unsigned_t<T>;
    using UU = tools::make_unsigned_t<U>;
    if constexpr (tools::is_signed_v<T> == tools::is_signed_v<U>) {
      return t < u;
    } else if constexpr (tools::is_signed_v<T>) {
      return t < 0 ? true : static_cast<UT>(t) < u;
    } else {
      return u < 0 ? false : t < static_cast<UU>(u);
    }
  }
}


#line 6 "tools/cmp_less_equal.hpp"

namespace tools {
  template <tools::integral T, tools::integral U>
  constexpr bool cmp_less_equal(const T t, const U u) noexcept {
    return !tools::cmp_less(u, t);
  }
}

Back to top page