randomize.hpp

Go to the documentation of this file.

/* This file is part of OpenKalman, a header-only C++ library for
 * Kalman filters and other recursive filters.
 *
 * Copyright (c) 2022-2024 Christopher Lee Ogden <ogden@gatech.edu>
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */

#ifndef OPENKALMAN_RANDOMIZE_HPP
#define OPENKALMAN_RANDOMIZE_HPP

namespace OpenKalman
{
  // ----------- //
  //  randomize  //
  // ----------- //

  namespace detail
  {
#ifndef __cpp_concepts
    template<typename T, typename = void, typename = void>
    struct is_std_dist : std::false_type {};

    template<typename T>
    struct is_std_dist<T, std::void_t<typename T::result_type>, std::void_t<typename T::param_type>> : std::true_type {};
#endif


    template<typename random_number_generator>
    struct RandomizeGenerator
    {
      static auto& get()
      {
        static std::random_device rd;
        static std::decay_t<random_number_generator> gen {rd()};
        return gen;
      }
    };


    template<typename random_number_generator, typename distribution_type>
    struct RandomizeOp
    {
      template<typename G, typename D>
      RandomizeOp(G& g, D&& d) : generator{g}, distribution{std::forward<D>(d)} {}

      auto operator()() const
      {
        if constexpr (std::is_arithmetic_v<distribution_type>)
          return distribution;
        else
          return distribution(generator);
      }

    private:

      std::decay_t<random_number_generator>& generator;
      mutable std::decay_t<distribution_type> distribution;
    };


    template<typename G, typename D>
    RandomizeOp(G&, D&&) -> RandomizeOp<G, D>;

  } // namespace detail


#ifdef __cpp_concepts
  template<indexible PatternMatrix, std::size_t...indices, std::uniform_random_bit_generator random_number_generator,
    coordinates::pattern...Ds, typename...Dists>
  requires ((fixed_pattern<std::tuple_element_t<indices, std::tuple<Ds...>>>) and ...) and
    (sizeof...(Dists) == (1 * ... * coordinates::dimension_of_v<std::tuple_element_t<indices, std::tuple<Ds...>>>)) and
    ((std::is_arithmetic_v<std::decay_t<Dists>> or
      requires { typename std::decay_t<Dists>::result_type; typename std::decay_t<Dists>::param_type; }) and ...)
#else
  template<typename PatternMatrix, std::size_t...indices, typename random_number_generator, typename...Ds,
    typename...Dists, std::enable_if_t<indexible<PatternMatrix> and (coordinates::pattern<Ds> and ...) and
    ((fixed_pattern<std::tuple_element_t<indices, std::tuple<Ds...>>>) and ...) and
    (sizeof...(Dists) == (1 * ... * coordinates::dimension_of<std::tuple_element_t<indices, std::tuple<Ds...>>>::value)) and
    ((std::is_arithmetic_v<std::decay_t<Dists>> or detail::is_std_dist<std::decay_t<Dists>>::value) and ...), int> = 0>
#endif
  constexpr auto
  randomize(random_number_generator& gen, const std::tuple<Ds...>& ds_tuple, Dists&&...dists)
  {
    auto ret {n_ary_operation<PatternMatrix, indices...>(ds_tuple, detail::RandomizeOp {gen, (std::forward<Dists>(dists))}...)};
    if constexpr (sizeof...(Dists) == 1) return to_dense_object(std::move(ret));
    else return ret;
  }


#ifdef __cpp_concepts
  template<indexible PatternMatrix, std::size_t...indices, coordinates::pattern...Ds, typename...Dists>
  requires ((fixed_pattern<std::tuple_element_t<indices, std::tuple<Ds...>>>) and ...) and
    (sizeof...(Dists) == (1 * ... * coordinates::dimension_of_v<std::tuple_element_t<indices, std::tuple<Ds...>>>)) and
    ((std::is_arithmetic_v<std::decay_t<Dists>> or
      requires { typename std::decay_t<Dists>::result_type; typename std::decay_t<Dists>::param_type; }) and ...)
#else
  template<typename PatternMatrix, std::size_t...indices, typename...Ds, typename...Dists,
    std::enable_if_t<indexible<PatternMatrix> and (coordinates::pattern<Ds> and ...) and
    ((fixed_pattern<std::tuple_element_t<indices, std::tuple<Ds...>>>) and ...) and
    (sizeof...(Dists) == (1 * ... * coordinates::dimension_of<std::tuple_element_t<indices, std::tuple<Ds...>>>::value)) and
    ((std::is_arithmetic_v<std::decay_t<Dists>> or detail::is_std_dist<std::decay_t<Dists>>::value) and ...), int> = 0>
#endif
  constexpr auto
  randomize(const std::tuple<Ds...>& d_tuple, Dists&&...dists)
  {
    auto& gen = detail::RandomizeGenerator<std::mt19937>::get();
    return randomize<PatternMatrix, indices...>(gen, d_tuple, std::forward<Dists>(dists)...);
  }


#ifdef __cpp_concepts
  template<indexible PatternMatrix, std::size_t...indices, std::uniform_random_bit_generator random_number_generator,
    typename...Dists>
  requires (not has_dynamic_dimensions<PatternMatrix>) and
    (sizeof...(Dists) == (1 * ... * index_dimension_of_v<PatternMatrix, indices>)) and
    ((std::is_arithmetic_v<Dists> or requires { typename Dists::result_type; typename Dists::param_type; }) and ...)
#else
  template<typename PatternMatrix, std::size_t...indices, typename random_number_generator, typename...Dists,
    std::enable_if_t<indexible<PatternMatrix> and (not has_dynamic_dimensions<PatternMatrix>) and
    (sizeof...(Dists) == (1 * ... * index_dimension_of<PatternMatrix, indices>::value)) and
    ((std::is_arithmetic_v<Dists> or detail::is_std_dist<Dists>::value) and ...), int> = 0>
#endif
  constexpr auto
  randomize(random_number_generator& gen, Dists&&...dists)
  {
    auto d_tup = all_vector_space_descriptors<PatternMatrix>();
    return randomize<PatternMatrix, indices...>(gen, d_tup, std::forward<Dists>(dists)...);
  }


#ifdef __cpp_concepts
  template<indexible PatternMatrix, std::size_t...indices, typename...Dists>
  requires (not has_dynamic_dimensions<PatternMatrix>) and
    (sizeof...(Dists) == (1 * ... * index_dimension_of_v<PatternMatrix, indices>)) and
    ((std::is_arithmetic_v<Dists> or requires { typename Dists::result_type; typename Dists::param_type; }) and ...)
#else
  template<typename PatternMatrix, std::size_t...indices, typename...Dists, std::enable_if_t<
    indexible<PatternMatrix> and (not has_dynamic_dimensions<PatternMatrix>) and
    (sizeof...(Dists) == (1 * ... * index_dimension_of<PatternMatrix, indices>::value)) and
    ((std::is_arithmetic_v<Dists> or detail::is_std_dist<Dists>::value) and ...), int> = 0>
#endif
  constexpr auto
  randomize(Dists&&...dists)
  {
    auto& gen = detail::RandomizeGenerator<std::mt19937>::get();
    return randomize<PatternMatrix, indices...>(gen, std::forward<Dists>(dists)...);
  }


} // namespace OpenKalman

#endif //OPENKALMAN_RANDOMIZE_HPP