is_complex.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_PRIM_META_IS_COMPLEX_HPP
#define STAN_MATH_PRIM_META_IS_COMPLEX_HPP
 
#include <stan/math/prim/meta/conjunction.hpp>
#include <stan/math/prim/meta/is_autodiff.hpp>
#include <stan/math/prim/meta/base_type.hpp>
#include <stan/math/prim/meta/scalar_type.hpp>
#include <stan/math/prim/meta/value_type.hpp>
#include <stan/math/prim/meta/require_helpers.hpp>
 
#include <complex>
#include <type_traits>
 
namespace stan {
namespace internal {
 
template <typename T>
struct is_complex_impl : std::false_type {};
 
template <typename... Ts>
struct is_complex_impl<std::complex<Ts...>> : std::true_type {};
 
}  // namespace internal
 
template <typename T, typename = void>
struct is_complex : std::false_type {};
 
template <typename T>
struct is_complex<
    T, std::enable_if_t<internal::is_complex_impl<std::decay_t<T>>::value>>
    : std::true_type {};
 
template <typename T>
struct scalar_type<T, std::enable_if_t<is_complex<T>::value>> {
  using type = std::complex<typename std::decay_t<T>::value_type>;
};
 
template <typename T>
struct base_type<T, std::enable_if_t<is_complex<T>::value>> {
  using type = base_type_t<typename std::decay_t<T>::value_type>;
};
 
template <typename T, typename = void>
struct is_complex_arithmetic : std::false_type {};
 
template <typename T>
struct is_complex_arithmetic<
    T, std::enable_if_t<stan::math::conjunction<
           std::is_arithmetic<base_type_t<T>>,
           internal::is_complex_impl<std::decay_t<T>>>::value>>
    : std::true_type {};
 
template <typename T, typename = void>
struct is_complex_ad : std::false_type {};
 
template <typename T>
struct is_complex_ad<T, std::enable_if_t<stan::math::conjunction<
                            is_autodiff<base_type_t<T>>,
                            internal::is_complex_impl<std::decay_t<T>>>::value>>
    : std::true_type {};
 
template <typename T>
using require_complex_t = require_t<is_complex<std::decay_t<T>>>;
 
template <typename T>
using require_not_complex_t = require_not_t<is_complex<std::decay_t<T>>>;
 
template <typename... Types>
using require_all_complex_t = require_all_t<is_complex<std::decay_t<Types>>...>;
 
template <typename... Types>
using require_any_complex_t = require_any_t<is_complex<std::decay_t<Types>>...>;
 
template <typename... Types>
using require_all_not_complex_t
    = require_all_not_t<is_complex<std::decay_t<Types>>...>;
template <typename T>
using require_vt_complex = require_t<is_complex<value_type_t<std::decay_t<T>>>>;
 
template <typename T>
using require_not_vt_complex
    = require_not_t<is_complex<value_type_t<std::decay_t<T>>>>;
 
template <typename T>
using require_not_st_complex
    = require_not_t<is_complex<scalar_type_t<std::decay_t<T>>>>;
 
template <template <class...> class TypeCheck, class Check>
using require_complex_bt
    = require_all_t<is_complex<Check>, TypeCheck<base_type_t<Check>>>;
 
template <typename T>
struct is_vt_complex : is_complex<value_type_t<std::decay_t<T>>> {};
 
template <typename T>
struct is_vt_not_complex
    : bool_constant<!is_complex<value_type_t<std::decay_t<T>>>::value> {};
 
}  // namespace stan
 
#endif