libMesh::Kokkos::detail Namespace Reference

Classes
struct	divide_value
struct	negate_value
	Componentwise transform functors, shared by the vector helpers here and the tensor helpers in kokkos_tensor_ops.h. More...
struct	scale_value

Typedefs
template<typename T >
using	remove_cvref_t = typename std::remove_cv< typename std::remove_reference< T >::type >::type
	Strips reference and const/volatile qualifiers from T, turning e.g.
template<typename ViewType >
using	vector_view_value_t = remove_cvref_t< decltype(std::declval< ViewType & >()(0, 0))>
	The plain component type stored by a vector view.
template<typename ViewType >
using	tensor_view_value_t = remove_cvref_t< decltype(std::declval< ViewType & >()(0, 0, 0))>
	The plain component type stored by a tensor view, recovered from an (entry, row, column) indexing expression the same way vector_view_value_t is from its (entry, component) expression.

Functions
template<typename TensorLike >
LIBMESH_DEVICE_INLINE TensorLike::value_type	leading_determinant (const TensorLike &T_in, const unsigned int dim=LIBMESH_DIM)
template<typename ResultTensor , typename LeftVector , typename RightVector >
LIBMESH_DEVICE_INLINE ResultTensor	outer_product (const LeftVector &left, const RightVector &right)
template<typename ResultTensor , typename TensorLike >
LIBMESH_DEVICE_INLINE ResultTensor	inverse (const TensorLike &T_in, const unsigned int dim=LIBMESH_DIM)
template<typename ResultTensor , typename TensorLike >
LIBMESH_DEVICE_INLINE ResultTensor	transpose (const TensorLike &T_in)
template<typename ResultTensor , typename LeftTensor , typename RightTensor >
LIBMESH_DEVICE_INLINE ResultTensor	multiply_tensors (const LeftTensor &left, const RightTensor &right)
template<typename ResultVector , typename TensorLike >
LIBMESH_DEVICE_INLINE ResultVector	row (const TensorLike &T_in, const unsigned int row_index)
template<typename ResultVector , typename TensorLike >
LIBMESH_DEVICE_INLINE ResultVector	column (const TensorLike &T_in, const unsigned int col_index)
template<typename ResultVector , typename TensorLike , typename VectorLike >
LIBMESH_DEVICE_INLINE ResultVector	multiply_tensor_vector (const TensorLike &T_in, const VectorLike &v)
template<typename ResultVector , typename VectorLike , typename TensorLike >
LIBMESH_DEVICE_INLINE ResultVector	multiply_vector_tensor (const VectorLike &v, const TensorLike &T_in)
template<typename LeftTensor , typename RightTensor >
LIBMESH_DEVICE_INLINE void	assign_tensor_components (LeftTensor &left, const RightTensor &right)
	Componentwise copy: left = right.
template<typename TensorLike , typename Scalar >
LIBMESH_DEVICE_INLINE void	fill_tensor_components (TensorLike &T_in, const Scalar &value)
	Sets every component of T_in to value.
template<typename LeftTensor , typename RightTensor , typename Scalar >
LIBMESH_DEVICE_INLINE void	update_tensor_components (LeftTensor &left, const RightTensor &right, const Scalar &factor)
	Componentwise axpy-style update: left += factor * right.
template<typename OutputTensor , typename InputTensor , typename TransformOp >
LIBMESH_DEVICE_INLINE void	transform_tensor_components (OutputTensor &out, const InputTensor &in, const TransformOp &op)
	Componentwise transform: out(i,j) = op(in(i,j)).
template<typename ResultTensor , typename TensorLike , typename TransformOp >
LIBMESH_DEVICE_INLINE ResultTensor	transformed_tensor (const TensorLike &T_in, const TransformOp &op)
template<typename LeftTensor , typename RightTensor >
LIBMESH_DEVICE_INLINE bool	tensor_equal_impl (const LeftTensor &left, const RightTensor &right)
template<typename LeftTensor , typename RightTensor >
LIBMESH_DEVICE_INLINE auto	tensor_contract (const LeftTensor &left, const RightTensor &right)
template<typename TensorLike >
LIBMESH_DEVICE_INLINE auto	tensor_trace (const TensorLike &T_in)
template<typename LeftVector , typename RightVector >
LIBMESH_DEVICE_INLINE void	assign_vector_components (LeftVector &left, const RightVector &right)
	Componentwise copy: left = right.
template<typename VectorLike , typename Scalar >
LIBMESH_DEVICE_INLINE void	fill_vector_components (VectorLike &v, const Scalar &value)
	Sets every component of v to value.
template<typename LeftVector , typename RightVector , typename Scalar >
LIBMESH_DEVICE_INLINE void	update_vector_components (LeftVector &left, const RightVector &right, const Scalar &factor)
	Componentwise axpy-style update: left += factor * right.
template<typename OutputVector , typename InputVector , typename TransformOp >
LIBMESH_DEVICE_INLINE void	transform_vector_components (OutputVector &out, const InputVector &in, const TransformOp &op)
	Componentwise transform: out(i) = op(in(i)).
template<typename ResultVector , typename VectorLike , typename TransformOp >
LIBMESH_DEVICE_INLINE ResultVector	transformed_vector (const VectorLike &v, const TransformOp &op)
template<typename LeftVector , typename RightVector >
LIBMESH_DEVICE_INLINE bool	vector_equal_impl (const LeftVector &left, const RightVector &right)

Typedef Documentation

remove_cvref_t

template<typename T >

using libMesh::Kokkos::detail::remove_cvref_t = typedef typename std::remove_cv<typename std::remove_reference<T>::type>::type

Strips reference and const/volatile qualifiers from T, turning e.g.

const Real& into plain Real. Equivalent of C++20's std::remove_cvref_t, hand-rolled while we only require C++17 support.

Definition at line 70 of file kokkos_linalg_base.h.

tensor_view_value_t

template<typename ViewType >

using libMesh::Kokkos::detail::tensor_view_value_t = typedef remove_cvref_t<decltype(std::declval<ViewType &>()(0, 0, 0))>

The plain component type stored by a tensor view, recovered from an (entry, row, column) indexing expression the same way vector_view_value_t is from its (entry, component) expression.

Definition at line 91 of file kokkos_linalg_base.h.

vector_view_value_t

template<typename ViewType >

using libMesh::Kokkos::detail::vector_view_value_t = typedef remove_cvref_t<decltype(std::declval<ViewType &>()(0, 0))>

The plain component type stored by a vector view.

Indexing a view at an (entry, component) pair yields a reference into the view's memory (e.g. Real& , or const Real& for a view of const data), so this strips the reference and any cv-qualifiers to recover the value type itself - the type needed to declare accumulators, make zeros like value_type(0), or materialize owning results.

Definition at line 82 of file kokkos_linalg_base.h.

Function Documentation

assign_tensor_components()

template<typename LeftTensor , typename RightTensor >

LIBMESH_DEVICE_INLINE void libMesh::Kokkos::detail::assign_tensor_components	(	LeftTensor &	left,
		const RightTensor &	right
	)

Componentwise copy: left = right.

Definition at line 351 of file kokkos_tensor_ops.h.

{
  for (unsigned int row = 0; row < LIBMESH_DIM; ++row)
    for (unsigned int col = 0; col < LIBMESH_DIM; ++col)
      left(row, col) = right(row, col);
}

References row().

Referenced by libMesh::Kokkos::tensor_ref< ViewType >::assign().

assign_vector_components()

template<typename LeftVector , typename RightVector >

LIBMESH_DEVICE_INLINE void libMesh::Kokkos::detail::assign_vector_components	(	LeftVector &	left,
		const RightVector &	right
	)

Componentwise copy: left = right.

Definition at line 87 of file kokkos_vector_ops.h.

{
  for (unsigned int component = 0; component < LIBMESH_DIM; ++component)
    left(component) = right(component);
}

Referenced by libMesh::Kokkos::vector_ref< ViewType >::assign().

column()

template<typename ResultVector , typename TensorLike >

LIBMESH_DEVICE_INLINE ResultVector libMesh::Kokkos::detail::column	(	const TensorLike &	T_in,
		const unsigned int	col_index
	)

Returns

Column col_index of T_in as an owning ResultVector.

Definition at line 289 of file kokkos_tensor_ops.h.

{
  ResultVector out;
  out.zero();
 
  for (unsigned int row_index = 0; row_index < LIBMESH_DIM; ++row_index)
    out(row_index) = T_in(row_index, col_index);
 
  return out;
}

References libMesh::out.

fill_tensor_components()

template<typename TensorLike , typename Scalar >

LIBMESH_DEVICE_INLINE void libMesh::Kokkos::detail::fill_tensor_components	(	TensorLike &	T_in,
		const Scalar &	value
	)

Sets every component of T_in to value.

Definition at line 363 of file kokkos_tensor_ops.h.

{
  for (unsigned int row = 0; row < LIBMESH_DIM; ++row)
    for (unsigned int col = 0; col < LIBMESH_DIM; ++col)
      T_in(row, col) = value;
}

References row(), and value.

Referenced by libMesh::Kokkos::tensor_ref< ViewType >::zero().

fill_vector_components()

template<typename VectorLike , typename Scalar >

LIBMESH_DEVICE_INLINE void libMesh::Kokkos::detail::fill_vector_components	(	VectorLike &	v,
		const Scalar &	value
	)

Sets every component of v to value.

Definition at line 98 of file kokkos_vector_ops.h.

{
  for (unsigned int component = 0; component < LIBMESH_DIM; ++component)
    v(component) = value;
}

References value.

Referenced by libMesh::Kokkos::vector_ref< ViewType >::zero().

inverse()

template<typename ResultTensor , typename TensorLike >

LIBMESH_DEVICE_INLINE ResultTensor libMesh::Kokkos::detail::inverse	(	const TensorLike &	T_in,
		const unsigned int	dim = LIBMESH_DIM
	)

Returns

The inverse of the leading dim x dim block of T_in as an owning ResultTensor, computed from the closed-form adjugate for dim <= 3. Components outside the leading block are zero.

Definition at line 170 of file kokkos_tensor_ops.h.

{
  static_assert(is_tensor_like_v<TensorLike>, "detail::inverse() requires a tensor-like input");
 
  ResultTensor out;
  out.zero();
 
  if (dim == 0)
    return out;
 
  if (dim == 1)
  {
    using value_type = typename ResultTensor::value_type;
    out(0, 0) = value_type(1) / T_in(0, 0);
    return out;
  }
 
  const auto det = leading_determinant(T_in, dim);
 
  if (dim == 2)
  {
    out(0, 0) = T_in(1, 1) / det;
    out(0, 1) = -T_in(0, 1) / det;
    out(1, 0) = -T_in(1, 0) / det;
    out(1, 1) =  T_in(0, 0) / det;
    return out;
  }
 
#if LIBMESH_DIM > 2
  const auto a00 = T_in(0, 0);
  const auto a01 = T_in(0, 1);
  const auto a02 = T_in(0, 2);
  const auto a10 = T_in(1, 0);
  const auto a11 = T_in(1, 1);
  const auto a12 = T_in(1, 2);
  const auto a20 = T_in(2, 0);
  const auto a21 = T_in(2, 1);
  const auto a22 = T_in(2, 2);
 
  out(0, 0) = (a11 * a22 - a12 * a21) / det;
  out(0, 1) = (a02 * a21 - a01 * a22) / det;
  out(0, 2) = (a01 * a12 - a02 * a11) / det;
  out(1, 0) = (a12 * a20 - a10 * a22) / det;
  out(1, 1) = (a00 * a22 - a02 * a20) / det;
  out(1, 2) = (a02 * a10 - a00 * a12) / det;
  out(2, 0) = (a10 * a21 - a11 * a20) / det;
  out(2, 1) = (a01 * a20 - a00 * a21) / det;
  out(2, 2) = (a00 * a11 - a01 * a10) / det;
#else
  libmesh_ignore(T_in);
#endif
 
  return out;
}

References libMesh::Kokkos::det(), dim, leading_determinant(), libMesh::libmesh_ignore(), and libMesh::out.

leading_determinant()

template<typename TensorLike >

LIBMESH_DEVICE_INLINE TensorLike::value_type libMesh::Kokkos::detail::leading_determinant	(	const TensorLike &	T_in,
		const unsigned int	dim = LIBMESH_DIM
	)

Returns

The determinant of the leading dim x dim block of T_in, expanded in closed form for dim <= 3. A 0x0 determinant is 1 by convention.

Definition at line 109 of file kokkos_tensor_ops.h.

{
  static_assert(is_tensor_like_v<TensorLike>,
                "detail::leading_determinant() requires a tensor-like input");
 
  if (dim == 0)
    return 1;
 
  if (dim == 1)
    return T_in(0, 0);
 
  if (dim == 2)
    return T_in(0, 0) * T_in(1, 1) -
           T_in(0, 1) * T_in(1, 0);
 
#if LIBMESH_DIM > 2
  const auto a00 = T_in(0, 0);
  const auto a01 = T_in(0, 1);
  const auto a02 = T_in(0, 2);
  const auto a10 = T_in(1, 0);
  const auto a11 = T_in(1, 1);
  const auto a12 = T_in(1, 2);
  const auto a20 = T_in(2, 0);
  const auto a21 = T_in(2, 1);
  const auto a22 = T_in(2, 2);
 
  return a00 * (a11 * a22 - a12 * a21) -
         a01 * (a10 * a22 - a12 * a20) +
         a02 * (a10 * a21 - a11 * a20);
#else
  libmesh_ignore(T_in);
  return 0;
#endif
}

References dim, and libMesh::libmesh_ignore().

Referenced by libMesh::Kokkos::tensor_ref< ViewType >::det(), and inverse().

multiply_tensor_vector()

template<typename ResultVector , typename TensorLike , typename VectorLike >

LIBMESH_DEVICE_INLINE ResultVector libMesh::Kokkos::detail::multiply_tensor_vector	(	const TensorLike &	T_in,
		const VectorLike &	v
	)

Returns

The matrix-vector product T_in * v as an owning ResultVector.

Definition at line 308 of file kokkos_tensor_ops.h.

{
  ResultVector out;
  out.zero();
 
  for (unsigned int row = 0; row < LIBMESH_DIM; ++row)
  {
    auto value = T_in(row, 0) * v(0);
    for (unsigned int col = 1; col < LIBMESH_DIM; ++col)
      value += T_in(row, col) * v(col);
    out(row) = value;
  }
 
  return out;
}

References libMesh::out, row(), and value.

multiply_tensors()

template<typename ResultTensor , typename LeftTensor , typename RightTensor >

LIBMESH_DEVICE_INLINE ResultTensor libMesh::Kokkos::detail::multiply_tensors	(	const LeftTensor &	left,
		const RightTensor &	right
	)

Returns

The matrix product left * right as an owning ResultTensor.

Definition at line 250 of file kokkos_tensor_ops.h.

{
  ResultTensor out;
  out.zero();
 
  for (unsigned int row = 0; row < LIBMESH_DIM; ++row)
    for (unsigned int col = 0; col < LIBMESH_DIM; ++col)
    {
      auto value = left(row, 0) * right(0, col);
      for (unsigned int k = 1; k < LIBMESH_DIM; ++k)
        value += left(row, k) * right(k, col);
      out(row, col) = value;
    }
 
  return out;
}

References libMesh::out, row(), and value.

multiply_vector_tensor()

template<typename ResultVector , typename VectorLike , typename TensorLike >

LIBMESH_DEVICE_INLINE ResultVector libMesh::Kokkos::detail::multiply_vector_tensor	(	const VectorLike &	v,
		const TensorLike &	T_in
	)

Returns

The vector-matrix product v * T_in (i.e. T_in^T * v) as an owning ResultVector.

Definition at line 330 of file kokkos_tensor_ops.h.

{
  ResultVector out;
  out.zero();
 
  for (unsigned int col = 0; col < LIBMESH_DIM; ++col)
  {
    auto value = v(0) * T_in(0, col);
    for (unsigned int row = 1; row < LIBMESH_DIM; ++row)
      value += v(row) * T_in(row, col);
    out(col) = value;
  }
 
  return out;
}

References libMesh::out, row(), and value.

outer_product()

template<typename ResultTensor , typename LeftVector , typename RightVector >

LIBMESH_DEVICE_INLINE ResultTensor libMesh::Kokkos::detail::outer_product	(	const LeftVector &	left,
		const RightVector &	right
	)

Returns

The outer product left * conj(right)^T as an owning ResultTensor, conjugating the right operand as the host-side outer_product() free function in type_tensor.h does.

Definition at line 151 of file kokkos_tensor_ops.h.

{
  ResultTensor out;
  out.zero();
 
  for (unsigned int row = 0; row < LIBMESH_DIM; ++row)
    for (unsigned int col = 0; col < LIBMESH_DIM; ++col)
      out(row, col) = left(row) * libmesh_conj(right(col));
 
  return out;
}

References libMesh::libmesh_conj(), libMesh::out, and row().

row()

template<typename ResultVector , typename TensorLike >

LIBMESH_DEVICE_INLINE ResultVector libMesh::Kokkos::detail::row	(	const TensorLike &	T_in,
		const unsigned int	row_index
	)

Returns

Row row_index of T_in as an owning ResultVector.

Definition at line 272 of file kokkos_tensor_ops.h.

{
  ResultVector out;
  out.zero();
 
  for (unsigned int col = 0; col < LIBMESH_DIM; ++col)
    out(col) = T_in(row_index, col);
 
  return out;
}

References libMesh::out.

Referenced by assign_tensor_components(), fill_tensor_components(), multiply_tensor_vector(), multiply_tensors(), multiply_vector_tensor(), outer_product(), tensor_contract(), tensor_equal_impl(), transform_tensor_components(), transpose(), and update_tensor_components().

tensor_contract()

template<typename LeftTensor , typename RightTensor >

LIBMESH_DEVICE_INLINE auto libMesh::Kokkos::detail::tensor_contract	(	const LeftTensor &	left,
		const RightTensor &	right
	)

Returns

The full contraction (sum of componentwise products) of left with right.

Definition at line 432 of file kokkos_tensor_ops.h.

{
  static_assert(is_tensor_like_v<LeftTensor>, "tensor_contract() requires a tensor-like left input");
  static_assert(is_tensor_like_v<RightTensor>, "tensor_contract() requires a tensor-like right input");
 
  using sum_type =
    detail::remove_cvref_t<decltype(left(0, 0) * right(0, 0))>;
 
  sum_type sum = sum_type(0);
  for (unsigned int row = 0; row < LIBMESH_DIM; ++row)
    for (unsigned int col = 0; col < LIBMESH_DIM; ++col)
      sum += left(row, col) * right(row, col);
 
  return sum;
}

References row().

Referenced by libMesh::Kokkos::contract().

tensor_equal_impl()

template<typename LeftTensor , typename RightTensor >

LIBMESH_DEVICE_INLINE bool libMesh::Kokkos::detail::tensor_equal_impl	(	const LeftTensor &	left,
		const RightTensor &	right
	)

Returns

true if left and right agree exactly in every component, false otherwise.

Definition at line 414 of file kokkos_tensor_ops.h.

{
  for (unsigned int row = 0; row < LIBMESH_DIM; ++row)
    for (unsigned int col = 0; col < LIBMESH_DIM; ++col)
      if (left(row, col) != right(row, col))
        return false;
 
  return true;
}

References row().

Referenced by libMesh::Kokkos::operator==().

tensor_trace()

template<typename TensorLike >

LIBMESH_DEVICE_INLINE auto libMesh::Kokkos::detail::tensor_trace

(

const TensorLike &

T_in

)

Returns

The trace of T_in.

Definition at line 454 of file kokkos_tensor_ops.h.

{
  static_assert(is_tensor_like_v<TensorLike>, "tensor_trace() requires a tensor-like input");
 
  using trace_type = detail::remove_cvref_t<decltype(T_in(0, 0))>;
  trace_type sum = trace_type(0);
  for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
    sum += T_in(i, i);
 
  return sum;
}

Referenced by libMesh::Kokkos::tensor_ref< ViewType >::tr().

transform_tensor_components()

template<typename OutputTensor , typename InputTensor , typename TransformOp >

LIBMESH_DEVICE_INLINE void libMesh::Kokkos::detail::transform_tensor_components	(	OutputTensor &	out,
		const InputTensor &	in,
		const TransformOp &	op
	)

Componentwise transform: out(i,j) = op(in(i,j)).

out and in may alias, as they do in the compound assignment operators below.

Definition at line 388 of file kokkos_tensor_ops.h.

{
  for (unsigned int row = 0; row < LIBMESH_DIM; ++row)
    for (unsigned int col = 0; col < LIBMESH_DIM; ++col)
      out(row, col) = op(in(row, col));
}

References libMesh::out, and row().

Referenced by libMesh::Kokkos::operator*=(), libMesh::Kokkos::operator/=(), and transformed_tensor().

transform_vector_components()

template<typename OutputVector , typename InputVector , typename TransformOp >

LIBMESH_DEVICE_INLINE void libMesh::Kokkos::detail::transform_vector_components	(	OutputVector &	out,
		const InputVector &	in,
		const TransformOp &	op
	)

Componentwise transform: out(i) = op(in(i)).

out and in may alias, as they do in the compound assignment operators below.

Definition at line 121 of file kokkos_vector_ops.h.

{
  for (unsigned int component = 0; component < LIBMESH_DIM; ++component)
    out(component) = op(in(component));
}

References libMesh::out.

Referenced by libMesh::Kokkos::operator*=(), libMesh::Kokkos::operator/=(), and transformed_vector().

transformed_tensor()

template<typename ResultTensor , typename TensorLike , typename TransformOp >

LIBMESH_DEVICE_INLINE ResultTensor libMesh::Kokkos::detail::transformed_tensor	(	const TensorLike &	T_in,
		const TransformOp &	op
	)

Returns

A new owning ResultTensor with components op(T_in(i,j)).

Definition at line 400 of file kokkos_tensor_ops.h.

{
  ResultTensor out;
  out.zero();
  transform_tensor_components(out, T_in, op);
  return out;
}

References libMesh::out, and transform_tensor_components().

transformed_vector()

template<typename ResultVector , typename VectorLike , typename TransformOp >

LIBMESH_DEVICE_INLINE ResultVector libMesh::Kokkos::detail::transformed_vector	(	const VectorLike &	v,
		const TransformOp &	op
	)

Returns

A new owning ResultVector with components op(v(i)).

Definition at line 132 of file kokkos_vector_ops.h.

{
  ResultVector out;
  out.zero();
  transform_vector_components(out, v, op);
  return out;
}

References libMesh::out, and transform_vector_components().

transpose()

template<typename ResultTensor , typename TensorLike >

LIBMESH_DEVICE_INLINE ResultTensor libMesh::Kokkos::detail::transpose

(

const TensorLike &

T_in

)

Returns

The transpose of T_in as an owning ResultTensor.

Definition at line 230 of file kokkos_tensor_ops.h.

{
  ResultTensor out;
  out.zero();
 
  for (unsigned int row = 0; row < LIBMESH_DIM; ++row)
    for (unsigned int col = 0; col < LIBMESH_DIM; ++col)
      out(row, col) = T_in(col, row);
 
  return out;
}

References libMesh::out, and row().

update_tensor_components()

template<typename LeftTensor , typename RightTensor , typename Scalar >

LIBMESH_DEVICE_INLINE void libMesh::Kokkos::detail::update_tensor_components	(	LeftTensor &	left,
		const RightTensor &	right,
		const Scalar &	factor
	)

Componentwise axpy-style update: left += factor * right.

Definition at line 375 of file kokkos_tensor_ops.h.

{
  for (unsigned int row = 0; row < LIBMESH_DIM; ++row)
    for (unsigned int col = 0; col < LIBMESH_DIM; ++col)
      left(row, col) = left(row, col) + factor * right(row, col);
}

References row().

Referenced by libMesh::Kokkos::tensor_ref< ViewType >::add_scaled(), libMesh::Kokkos::operator+=(), libMesh::Kokkos::operator-=(), and libMesh::Kokkos::tensor_ref< ViewType >::subtract_scaled().

update_vector_components()

template<typename LeftVector , typename RightVector , typename Scalar >

LIBMESH_DEVICE_INLINE void libMesh::Kokkos::detail::update_vector_components	(	LeftVector &	left,
		const RightVector &	right,
		const Scalar &	factor
	)

Componentwise axpy-style update: left += factor * right.

Definition at line 109 of file kokkos_vector_ops.h.

{
  for (unsigned int component = 0; component < LIBMESH_DIM; ++component)
    left(component) = left(component) + factor * right(component);
}

Referenced by libMesh::Kokkos::vector_ref< ViewType >::add_scaled(), libMesh::Kokkos::operator+=(), libMesh::Kokkos::operator-=(), and libMesh::Kokkos::vector_ref< ViewType >::subtract_scaled().

vector_equal_impl()

template<typename LeftVector , typename RightVector >

LIBMESH_DEVICE_INLINE bool libMesh::Kokkos::detail::vector_equal_impl	(	const LeftVector &	left,
		const RightVector &	right
	)

Returns

true if left and right agree exactly in every component, false otherwise.

Definition at line 146 of file kokkos_vector_ops.h.

{
  for (unsigned int component = 0; component < LIBMESH_DIM; ++component)
    if (left(component) != right(component))
      return false;
 
  return true;
}

Referenced by libMesh::Kokkos::operator==().