Least Prime Factor
(src/number_theory/least_factor.hpp)

• View this file on GitHub
• Last update: 2022-04-06 15:02:09+09:00
• Include: #include "src/number_theory/least_factor.hpp"

Depends on

• SFINAE (src/utils/sfinae.hpp)

Code

#pragma once

/*
 * @file least_factor.hpp
 * @brief Least Prime Factor
 */

#include <cassert>
#include <vector>

#include "src/utils/sfinae.hpp"

namespace workspace {

/*
 * @class least_factor
 * @brief Calculate the least prime factor for positive integers.
 * @tparam N Range of calculation, exclusive
 */
template <unsigned N> class least_factor {
  unsigned least[N], prime[N >> 3], n;

 public:
  constexpr least_factor() : least{1}, prime{}, n{} {
    for (auto i = 2u; i < N; ++i) {
      if (!least[i]) prime[n++] = least[i] = i;
      for (auto *p = prime; *p && *p <= least[i] && *p * i < N; ++p) {
        least[*p * i] = *p;
      }
    }
  }

  /*
   * @param x an integer with 0 < |x| < N
   * @return Least prime factor of x
   */
  template <typename int_type>
  constexpr
      typename std::enable_if<is_integral_ext<int_type>::value, int_type>::type
      operator()(int_type x) const {
    assert(x);
    if (x < 0) x = -x;
    assert(x < N);
    return least[x];
  }

  /*
   * @fn primes
   * @return Sorted list of prime numbers less than N
   */
  const std::vector<unsigned> &primes() const {
    static const std::vector<unsigned> prime_vector(prime, prime + n);
    return prime_vector;
  }
};

}  // namespace workspace

#line 2 "src/number_theory/least_factor.hpp"

/*
 * @file least_factor.hpp
 * @brief Least Prime Factor
 */

#include <cassert>
#include <vector>

#line 2 "src/utils/sfinae.hpp"

/**
 * @file sfinae.hpp
 * @brief SFINAE
 */

#include <cstdint>
#include <iterator>
#include <type_traits>

#ifndef __INT128_DEFINED__

#ifdef __SIZEOF_INT128__
#define __INT128_DEFINED__ 1
#else
#define __INT128_DEFINED__ 0
#endif

#endif

namespace std {

#if __INT128_DEFINED__

template <> struct make_signed<__uint128_t> { using type = __int128_t; };
template <> struct make_signed<__int128_t> { using type = __int128_t; };

template <> struct make_unsigned<__uint128_t> { using type = __uint128_t; };
template <> struct make_unsigned<__int128_t> { using type = __uint128_t; };

template <> struct is_signed<__uint128_t> : std::false_type {};
template <> struct is_signed<__int128_t> : std::true_type {};

template <> struct is_unsigned<__uint128_t> : std::true_type {};
template <> struct is_unsigned<__int128_t> : std::false_type {};

#endif

}  // namespace std

namespace workspace {

template <class Tp, class... Args> struct variadic_front { using type = Tp; };

template <class... Args> struct variadic_back;

template <class Tp> struct variadic_back<Tp> { using type = Tp; };

template <class Tp, class... Args> struct variadic_back<Tp, Args...> {
  using type = typename variadic_back<Args...>::type;
};

template <class type, template <class> class trait>
using enable_if_trait_type = typename std::enable_if<trait<type>::value>::type;

/**
 * @brief Return type of subscripting ( @c [] ) access.
 */
template <class _Tp>
using subscripted_type =
    typename std::decay<decltype(std::declval<_Tp&>()[0])>::type;

template <class Container>
using element_type = typename std::decay<decltype(*std::begin(
    std::declval<Container&>()))>::type;

template <class _Tp, class = void> struct has_begin : std::false_type {};

template <class _Tp>
struct has_begin<
    _Tp, std::__void_t<decltype(std::begin(std::declval<const _Tp&>()))>>
    : std::true_type {
  using type = decltype(std::begin(std::declval<const _Tp&>()));
};

template <class _Tp, class = void> struct has_size : std::false_type {};

template <class _Tp>
struct has_size<_Tp, std::__void_t<decltype(std::size(std::declval<_Tp>()))>>
    : std::true_type {};

template <class _Tp, class = void> struct has_resize : std::false_type {};

template <class _Tp>
struct has_resize<_Tp, std::__void_t<decltype(std::declval<_Tp>().resize(
                           std::declval<size_t>()))>> : std::true_type {};

template <class _Tp, class = void> struct has_mod : std::false_type {};

template <class _Tp>
struct has_mod<_Tp, std::__void_t<decltype(_Tp::mod)>> : std::true_type {};

template <class _Tp, class = void> struct is_integral_ext : std::false_type {};
template <class _Tp>
struct is_integral_ext<
    _Tp, typename std::enable_if<std::is_integral<_Tp>::value>::type>
    : std::true_type {};

#if __INT128_DEFINED__

template <> struct is_integral_ext<__int128_t> : std::true_type {};
template <> struct is_integral_ext<__uint128_t> : std::true_type {};

#endif

#if __cplusplus >= 201402

template <class _Tp>
constexpr static bool is_integral_ext_v = is_integral_ext<_Tp>::value;

#endif

template <typename _Tp, typename = void> struct multiplicable_uint {
  using type = uint_least32_t;
};
template <typename _Tp>
struct multiplicable_uint<
    _Tp,
    typename std::enable_if<(2 < sizeof(_Tp)) &&
                            (!__INT128_DEFINED__ || sizeof(_Tp) <= 4)>::type> {
  using type = uint_least64_t;
};

#if __INT128_DEFINED__

template <typename _Tp>
struct multiplicable_uint<_Tp,
                          typename std::enable_if<(4 < sizeof(_Tp))>::type> {
  using type = __uint128_t;
};

#endif

template <typename _Tp> struct multiplicable_int {
  using type =
      typename std::make_signed<typename multiplicable_uint<_Tp>::type>::type;
};

template <typename _Tp> struct multiplicable {
  using type = std::conditional_t<
      is_integral_ext<_Tp>::value,
      std::conditional_t<std::is_signed<_Tp>::value,
                         typename multiplicable_int<_Tp>::type,
                         typename multiplicable_uint<_Tp>::type>,
      _Tp>;
};

template <class> struct first_arg { using type = void; };

template <class _R, class _Tp, class... _Args>
struct first_arg<_R(_Tp, _Args...)> {
  using type = _Tp;
};

template <class _R, class _Tp, class... _Args>
struct first_arg<_R (*)(_Tp, _Args...)> {
  using type = _Tp;
};

template <class _G, class _R, class _Tp, class... _Args>
struct first_arg<_R (_G::*)(_Tp, _Args...)> {
  using type = _Tp;
};

template <class _G, class _R, class _Tp, class... _Args>
struct first_arg<_R (_G::*)(_Tp, _Args...) const> {
  using type = _Tp;
};

template <class _Tp, class = void> struct parse_compare : first_arg<_Tp> {};

template <class _Tp>
struct parse_compare<_Tp, std::__void_t<decltype(&_Tp::operator())>>
    : first_arg<decltype(&_Tp::operator())> {};

template <class _Container, class = void> struct get_dimension {
  static constexpr size_t value = 0;
};

template <class _Container>
struct get_dimension<_Container,
                     std::enable_if_t<has_begin<_Container>::value>> {
  static constexpr size_t value =
      1 + get_dimension<typename std::iterator_traits<
              typename has_begin<_Container>::type>::value_type>::value;
};

}  // namespace workspace
#line 12 "src/number_theory/least_factor.hpp"

namespace workspace {

/*
 * @class least_factor
 * @brief Calculate the least prime factor for positive integers.
 * @tparam N Range of calculation, exclusive
 */
template <unsigned N> class least_factor {
  unsigned least[N], prime[N >> 3], n;

 public:
  constexpr least_factor() : least{1}, prime{}, n{} {
    for (auto i = 2u; i < N; ++i) {
      if (!least[i]) prime[n++] = least[i] = i;
      for (auto *p = prime; *p && *p <= least[i] && *p * i < N; ++p) {
        least[*p * i] = *p;
      }
    }
  }

  /*
   * @param x an integer with 0 < |x| < N
   * @return Least prime factor of x
   */
  template <typename int_type>
  constexpr
      typename std::enable_if<is_integral_ext<int_type>::value, int_type>::type
      operator()(int_type x) const {
    assert(x);
    if (x < 0) x = -x;
    assert(x < N);
    return least[x];
  }

  /*
   * @fn primes
   * @return Sorted list of prime numbers less than N
   */
  const std::vector<unsigned> &primes() const {
    static const std::vector<unsigned> prime_vector(prime, prime + n);
    return prime_vector;
  }
};

}  // namespace workspace

Back to top page