global-definitions.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) 2021-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_GLOBAL_DEFINITIONS_HPP
#define OPENKALMAN_GLOBAL_DEFINITIONS_HPP

#include <type_traits>
#include <limits>
#include <functional>

namespace OpenKalman
{

#ifdef __cpp_lib_span
  inline constexpr std::size_t dynamic_size = std::dynamic_extent;
#else
  inline constexpr std::size_t dynamic_size = std::numeric_limits<std::size_t>::max();
#endif


  inline constexpr std::ptrdiff_t dynamic_difference = std::numeric_limits<std::ptrdiff_t>::max();


  enum struct Layout : int {
    none, 
    right, 
    left, 
    stride, 
  };


  enum struct TriangleType : int {
    diagonal, 
    lower, 
    upper, 
    any, 
    // \todo strict_diagonal,
      //< A specific diagonal object for rank 2k (k:ℕ) tensors in which each element is zero
      //< unless its indices can be divided into two identical sequences.
      //< (Examples, component x[1,0,2,1,0,2] in rank-6 tensor x or component y[2,5,2,5] in rank-4 tensor y.)
  };


  enum struct HermitianAdapterType : int {
    any = static_cast<int>(TriangleType::diagonal), 
    lower = static_cast<int>(TriangleType::lower), 
    upper = static_cast<int>(TriangleType::upper), 
  };


  enum struct Applicability : int {
    guaranteed, 
    permitted, 
  };


  constexpr Applicability operator not (Applicability x)
  {
    return x == Applicability::guaranteed ? Applicability::permitted : Applicability::guaranteed;
  }


  constexpr Applicability operator and (Applicability x, Applicability y)
  {
    return x == Applicability::guaranteed and y == Applicability::guaranteed ? Applicability::guaranteed : Applicability::permitted;
  }


  constexpr Applicability operator or (Applicability x, Applicability y)
  {
    return x == Applicability::guaranteed or y == Applicability::guaranteed ? Applicability::guaranteed : Applicability::permitted;
  }


  namespace internal
  {
    // ----------------------- //
    //  is_plus, is_multiplies //
    // ----------------------- //

    template<typename T>
    struct is_plus : std::false_type {};

    template<typename T>
    struct is_plus<std::plus<T>> : std::true_type {};

    template<typename T>
    struct is_multiplies : std::false_type {};

    template<typename T>
    struct is_multiplies<std::multiplies<T>> : std::true_type {};


    // ------------------------ //
    //  remove_rvalue_reference //
    // ------------------------ //

    template<typename T>
    struct remove_rvalue_reference
    {
      using type = std::conditional_t<std::is_rvalue_reference_v<T>, std::remove_reference_t<T>, T>;
    };


    template<typename T>
    using remove_rvalue_reference_t = typename remove_rvalue_reference<T>::type;


    // -------------------- //
    //  is_initializer_list //
    // -------------------- //

    template<typename T>
    struct is_initializer_list : std::false_type {};

    template<typename T>
    struct is_initializer_list<std::initializer_list<T>> : std::true_type {};

    template<typename T>
    struct is_initializer_list<T&> : is_initializer_list<T> {};

    template<typename T>
    struct is_initializer_list<T&&> : is_initializer_list<T> {};

    template<typename T>
    struct is_initializer_list<const T> : is_initializer_list<T> {};

    template<typename T>
    struct is_initializer_list<volatile T> : is_initializer_list<T> {};


  } // namespace internal

} // namespace OpenKalman

#endif //OPENKALMAN_GLOBAL_DEFINITIONS_HPP