Concepts

Reduced State

template<class T, class = void>
struct ReducedState : std::false_type{};

   >
  > : std::true_type{};

Subspaces

template<class T, class = void>
#endif

// ----------------------------------------------------------------------------
// SUBSPACES
// ----------------------------------------------------------------------------
template<class T, class enable = void>
struct VectorSubspace: std::false_type{};

template<class T>
struct VectorSubspace<
  T,
  std::enable_if_t<
    std::is_copy_constructible<T>::value
    && ::pressio::has_basis_matrix_typedef<T>::value
    && std::is_copy_constructible<typename T::basis_matrix_type>::value
    && all_have_traits<typename T::basis_matrix_type>::value
    && Traits<typename T::basis_matrix_type>::rank == 2
    && !std::is_assignable<T&, T>::value
    && !std::is_assignable<T&, T&>::value
    //
    && std::is_same<
      decltype( std::declval<T const>().basis() ),
      const typename T::basis_matrix_type &
      >::value
    && std::is_integral<
      decltype( std::declval<T const>().dimension() )
      >::value
    && std::is_same<
      decltype( std::declval<T const>().isColumnSpace() ),
      bool
      >::value
    && std::is_same<
      decltype( std::declval<T const>().isRowSpace() ),
      bool
      >::value
   >
  > : std::true_type{};


template<class T, class enable = void>
struct PossiblyAffineTrialColumnSubspace : std::false_type{};

template<class T>
struct PossiblyAffineTrialColumnSubspace<
  T,
  std::enable_if_t<
    ::pressio::has_reduced_state_typedef<T>::value
    && ReducedState<typename T::reduced_state_type>::value
    && ::pressio::has_basis_matrix_typedef<T>::value
    && ::pressio::has_full_state_typedef<T>::value
    && std::is_copy_constructible< typename T::full_state_type>::value
    && std::is_copy_constructible< typename T::basis_matrix_type>::value
    && all_have_traits<
      typename T::reduced_state_type,
      typename T::full_state_type,
      typename T::basis_matrix_type>::value
    && Traits<typename T::full_state_type>::rank == 1
    && Traits<typename T::basis_matrix_type>::rank == 2
    /**/
   >
  > : std::true_type{};

FOM Systems

template<class T, class = void>
    && std::is_same<
        decltype( std::declval<T const>().basis() ),
        const typename T::basis_matrix_type &
      >::value
    && std::is_integral<
      decltype( std::declval<T const>().dimension() )
      >::value
    //
    && std::is_same<
      decltype( std::declval<T const>().isColumnSpace() ),
      bool
      >::value
    && std::is_same<
      decltype( std::declval<T const>().isRowSpace() ),
      bool
      >::value
    >
  > : std::true_type{};


template<class T, class enable = void>
struct PossiblyAffineRealValuedTrialColumnSubspace: std::false_type{};

template<class T>
struct PossiblyAffineRealValuedTrialColumnSubspace<
  T,
  std::enable_if_t<
  PossiblyAffineTrialColumnSubspace<T>::value
  && std::is_floating_point< scalar_trait_t<typename T::reduced_state_type> >::value
  && std::is_floating_point< scalar_trait_t<typename T::full_state_type> >::value
  && std::is_floating_point< scalar_trait_t<typename T::basis_matrix_type> >::value
  >
> : std::true_type{};


// ----------------------------------------------------------------------------
// VARIOUS
// ----------------------------------------------------------------------------
template <class T, class MaskerType, class = void>
struct MaskableWith : std::false_type{};

template <class T, class MaskerType>
struct MaskableWith<
  T, MaskerType,
  std::enable_if_t<
    std::is_copy_constructible<
      decltype
      (std::declval<MaskerType const>().createResultOfMaskActionOn
       (std::declval<T const &>())
       )
    >::value
    && std::is_void<
	decltype
	(
	 std::declval<MaskerType const>()
	 (
	   std::declval<T const &>(),
	   std::declval<impl::mask_action_t<MaskerType, T> &>()
	 )
	)
       >::value
  >
> : std::true_type{};

// ----------------------------------------------------------------------------
// SYSTEMS
// ----------------------------------------------------------------------------

template<class T, class JacobianActionOperandType, class enable = void>
struct SteadyFomWithJacobianAction : std::false_type{};

template<class T, class JacobianActionOperandType>
struct SteadyFomWithJacobianAction<
  T, JacobianActionOperandType,
  std::enable_if_t<
       ::pressio::has_state_typedef<T>::value
    && ::pressio::has_residual_typedef<T>::value
    && std::is_copy_constructible<typename T::state_type>::value
    && std::is_copy_constructible<typename T::residual_type>::value
    /**/
    && ::pressio::rom::has_const_create_residual_method_return_result<
	 T, typename T::residual_type >::value
    && ::pressio::rom::has_const_create_result_of_jacobian_action_on<
	 T, JacobianActionOperandType>::value
    && std::is_copy_constructible<
	 impl::fom_jac_action_t<T, JacobianActionOperandType>
	 >::value
    /**/
    && std::is_void<
      decltype
      (
       std::declval<T const>().residualAndJacobianAction
       (
	std::declval<typename T::state_type const&>(),
	std::declval<typename T::residual_type &>(),
	std::declval<JacobianActionOperandType const&>(),
	std::declval< std::optional<impl::fom_jac_action_t<T, JacobianActionOperandType> *> >()
	)
       )
    >::value
   >
  > : std::true_type{};

template<class T, class enable = void>
struct SemiDiscreteFom : std::false_type{};
   >
  > : std::true_type{};

Real-valued FOM Systems Refinements

template<class T, class = void>
  T,
  std::enable_if_t<
       ::pressio::has_time_typedef<T>::value
    && ::pressio::has_state_typedef<T>::value
    && ::pressio::has_rhs_typedef<T>::value
    && std::is_copy_constructible<typename T::state_type>::value
    && std::is_copy_constructible<typename T::rhs_type>::value
    && ::pressio::ode::has_const_create_rhs_method_return_result<
      T, typename T::rhs_type >::value
    && ::pressio::rom::has_const_rhs_method_accept_state_indvar_result_return_void<
      T, typename T::state_type, typename T::time_type, typename T::rhs_type>::value
   >
  > : std::true_type{};


template<class T, class MassMatrixActionOperandType, class enable = void>
struct SemiDiscreteFomWithMassMatrixAction : std::false_type{};

template<class T, class MassMatrixActionOperandType>
struct SemiDiscreteFomWithMassMatrixAction<
  T, MassMatrixActionOperandType,
  std::enable_if_t<
    SemiDiscreteFom<T>::value
    //
    && std::is_copy_constructible<
      decltype
      (
       std::declval<T const>().createResultOfMassMatrixActionOn
       (
	std::declval<MassMatrixActionOperandType const &>()
	)
       )
      >::value
    && std::is_void<
       decltype
       (
	std::declval<T const>().applyMassMatrix
	(
	 std::declval<typename T::state_type const&>(),
	 std::declval<MassMatrixActionOperandType const&>(),
	 std::declval<typename T::time_type const &>(),
	 std::declval<impl::fom_mass_matrix_action_t<T,  MassMatrixActionOperandType> &>()
	 )
	)
       >::value
   >
   >
  > : std::true_type{};

Others

template<class T, class = void>
    && has_const_create_reduced_state_return_result<T>::value
    && has_const_create_full_state_return_result<T>::value
    && has_const_create_full_state_from_reduced_state<T>::value
    /**/
    && has_const_map_from_reduced_state_return_void<T>::value
    && std::is_same<
      decltype( std::declval<T const>().basisOfTranslatedSpace() ),
      typename T::basis_matrix_type const &
      >::value
    && std::is_same<
   >
  > : std::true_type{};