0,
(end - begin) * sizeof(T));
else
- copy_construct_or_assign(
- begin, end, std::integral_constant<bool, initialize_memory>());
+ copy_construct_or_assign(begin,
+ end,
+ std::bool_constant<initialize_memory>());
}
private:
void
copy_construct_or_assign(const std::size_t begin,
const std::size_t end,
- std::integral_constant<bool, false>) const
+ std::bool_constant<false>) const
{
for (std::size_t i = begin; i < end; ++i)
destination_[i] = element_;
void
copy_construct_or_assign(const std::size_t begin,
const std::size_t end,
- std::integral_constant<bool, true>) const
+ std::bool_constant<true>) const
{
for (std::size_t i = begin; i < end; ++i)
new (&destination_[i]) T(element_);
0,
(end - begin) * sizeof(T));
else
- default_construct_or_assign(
- begin, end, std::integral_constant<bool, initialize_memory>());
+ default_construct_or_assign(begin,
+ end,
+ std::bool_constant<initialize_memory>());
}
private:
void
default_construct_or_assign(const std::size_t begin,
const std::size_t end,
- std::integral_constant<bool, false>) const
+ std::bool_constant<false>) const
{
for (std::size_t i = begin; i < end; ++i)
destination_[i] = std::move(T());
void
default_construct_or_assign(const std::size_t begin,
const std::size_t end,
- std::integral_constant<bool, true>) const
+ std::bool_constant<true>) const
{
for (std::size_t i = begin; i < end; ++i)
new (&destination_[i]) T;
MatrixType &global_matrix,
VectorType &global_vector,
const bool use_inhomogeneities_for_rhs,
- const std::integral_constant<bool, false>) const;
+ const std::bool_constant<false>) const;
/**
* This function actually implements the local_to_global function for block
MatrixType &global_matrix,
VectorType &global_vector,
const bool use_inhomogeneities_for_rhs,
- const std::integral_constant<bool, true>) const;
+ const std::bool_constant<true>) const;
/**
* Internal helper function for distribute_local_to_global function.
void
set_zero_in_parallel(const std::vector<size_type> &cm,
VectorType &vec,
- std::integral_constant<bool, false>)
+ std::bool_constant<false>)
{
set_zero_parallel(cm, vec, 0);
}
void
set_zero_in_parallel(const std::vector<size_type> &cm,
VectorType &vec,
- std::integral_constant<bool, true>)
+ std::bool_constant<true>)
{
size_type start_shift = 0;
for (size_type j = 0; j < vec.n_blocks(); ++j)
set_zero_all(const std::vector<size_type> &cm, VectorType &vec)
{
set_zero_in_parallel<VectorType>(
- cm,
- vec,
- std::integral_constant<bool, IsBlockVector<VectorType>::value>());
+ cm, vec, std::bool_constant<IsBlockVector<VectorType>::value>());
vec.compress(VectorOperation::insert);
}
const IndexSet & /*locally_owned_elements*/,
const IndexSet &needed_elements,
TrilinosWrappers::MPI::Vector &output,
- const std::integral_constant<bool, false> /*is_block_vector*/)
+ const std::bool_constant<false> /*is_block_vector*/)
{
Assert(!vec.has_ghost_elements(), ExcGhostsPresent());
# ifdef DEAL_II_WITH_MPI
const IndexSet &locally_owned_elements,
const IndexSet &needed_elements,
PETScWrappers::MPI::Vector &output,
- const std::integral_constant<bool, false> /*is_block_vector*/)
+ const std::bool_constant<false> /*is_block_vector*/)
{
output.reinit(locally_owned_elements,
needed_elements,
const IndexSet &locally_owned_elements,
const IndexSet &needed_elements,
LinearAlgebra::distributed::Vector<number> &output,
- const std::integral_constant<bool, false> /*is_block_vector*/)
+ const std::bool_constant<false> /*is_block_vector*/)
{
// TODO: the in vector might already have all elements. need to find a
// way to efficiently avoid the copy then
const IndexSet & /*locally_owned_elements*/,
const IndexSet & /*needed_elements*/,
Vector & /*output*/,
- const std::integral_constant<bool, false> /*is_block_vector*/)
+ const std::bool_constant<false> /*is_block_vector*/)
{
Assert(false, ExcMessage("We shouldn't even get here!"));
}
const IndexSet &locally_owned_elements,
const IndexSet &needed_elements,
VectorType &output,
- const std::integral_constant<bool, true> /*is_block_vector*/)
+ const std::bool_constant<true> /*is_block_vector*/)
{
output.reinit(vec.n_blocks());
needed_elements.get_view(block_start,
block_start + vec.block(b).size()),
output.block(b),
- std::integral_constant<bool, false>());
+ std::bool_constant<false>());
block_start += vec.block(b).size();
}
vec_owned_elements,
needed_elements_for_distribute,
ghosted_vector,
- std::integral_constant<bool,
- IsBlockVector<VectorType>::value>());
+ std::bool_constant<IsBlockVector<VectorType>::value>());
}
else
{
vec_owned_elements,
complete_index_set(vec_owned_elements.size()),
ghosted_vector,
- std::integral_constant<bool,
- IsBlockVector<VectorType>::value>());
+ std::bool_constant<IsBlockVector<VectorType>::value>());
}
for (const ConstraintLine &line : lines)
MatrixType &global_matrix,
VectorType &global_vector,
const bool use_inhomogeneities_for_rhs,
- const std::integral_constant<bool, false>) const
+ const std::bool_constant<false>) const
{
// FIXME: static_assert MatrixType::value_type == number
MatrixType &global_matrix,
VectorType &global_vector,
const bool use_inhomogeneities_for_rhs,
- const std::integral_constant<bool, true>) const
+ const std::bool_constant<true>) const
{
const bool use_vectors =
(local_vector.size() == 0 && global_vector.size() == 0) ? false : true;
vmult(VectorType1 &dst,
const VectorType2 &src,
const bool transpose,
- const std::integral_constant<bool, true>,
- const std::integral_constant<bool, true>) const;
+ const std::bool_constant<true>,
+ const std::bool_constant<true>) const;
/**
* Internal version of (T)vmult where the source vector is a block vector
vmult(VectorType1 &dst,
const VectorType2 &src,
const bool transpose,
- const std::integral_constant<bool, false>,
- const std::integral_constant<bool, true>) const;
+ const std::bool_constant<false>,
+ const std::bool_constant<true>) const;
/**
* Internal version of (T)vmult where the source vector is a non-block
vmult(VectorType1 &dst,
const VectorType2 &src,
const bool transpose,
- const std::integral_constant<bool, true>,
- const std::integral_constant<bool, false>) const;
+ const std::bool_constant<true>,
+ const std::bool_constant<false>) const;
/**
* Internal version of (T)vmult where both source vector and the
vmult(VectorType1 &dst,
const VectorType2 &src,
const bool transpose,
- const std::integral_constant<bool, false>,
- const std::integral_constant<bool, false>) const;
+ const std::bool_constant<false>,
+ const std::bool_constant<false>) const;
};
vmult(dst,
src,
false,
- std::integral_constant<bool, IsBlockVector<VectorType1>::value>(),
- std::integral_constant<bool, IsBlockVector<VectorType2>::value>());
+ std::bool_constant<IsBlockVector<VectorType1>::value>(),
+ std::bool_constant<IsBlockVector<VectorType2>::value>());
}
vmult(dst,
src,
true,
- std::integral_constant<bool, IsBlockVector<VectorType1>::value>(),
- std::integral_constant<bool, IsBlockVector<VectorType2>::value>());
+ std::bool_constant<IsBlockVector<VectorType1>::value>(),
+ std::bool_constant<IsBlockVector<VectorType2>::value>());
}
BlockSparseMatrix::vmult(VectorType1 &dst,
const VectorType2 &src,
const bool transpose,
- std::integral_constant<bool, true>,
- std::integral_constant<bool, true>) const
+ std::bool_constant<true>,
+ std::bool_constant<true>) const
{
if (transpose == true)
BaseClass::Tvmult_block_block(dst, src);
BlockSparseMatrix::vmult(VectorType1 &dst,
const VectorType2 &src,
const bool transpose,
- std::integral_constant<bool, false>,
- std::integral_constant<bool, true>) const
+ std::bool_constant<false>,
+ std::bool_constant<true>) const
{
if (transpose == true)
BaseClass::Tvmult_nonblock_block(dst, src);
BlockSparseMatrix::vmult(VectorType1 &dst,
const VectorType2 &src,
const bool transpose,
- std::integral_constant<bool, true>,
- std::integral_constant<bool, false>) const
+ std::bool_constant<true>,
+ std::bool_constant<false>) const
{
if (transpose == true)
BaseClass::Tvmult_block_nonblock(dst, src);
BlockSparseMatrix::vmult(VectorType1 &dst,
const VectorType2 &src,
const bool transpose,
- std::integral_constant<bool, false>,
- std::integral_constant<bool, false>) const
+ std::bool_constant<false>,
+ std::bool_constant<false>) const
{
if (transpose == true)
BaseClass::Tvmult_nonblock_nonblock(dst, src);
// on the number types we are given. To choose the vectorized
// version often enough, we need to have all tasks but the last one
// to be divisible by the vectorization length
- size_type n_chunks = do_accumulate(
- op,
- vec_size,
- first,
- outer_results,
- std::integral_constant<bool, Operation::vectorizes>());
+ size_type n_chunks =
+ do_accumulate(op,
+ vec_size,
+ first,
+ outer_results,
+ std::bool_constant<Operation::vectorizes>());
AssertIndexRange(n_chunks,
vector_accumulation_recursion_threshold + 1);
const size_type vec_size,
const size_type start_index,
ResultType *outer_results,
- std::integral_constant<bool, false>)
+ std::bool_constant<false>)
{
// Create local copy to indicate no aliasing to the compiler
size_type index = start_index;
const size_type vec_size,
const size_type start_index,
Number *outer_results,
- std::integral_constant<bool, true>)
+ std::bool_constant<true>)
{
// Create local copy to indicate no aliasing to the compiler
size_type index = start_index;
const Number *values_dofs,
FEEvaluationData<dim, Number, false> &fe_eval,
const bool sum_into_values_array,
- std::integral_constant<bool, false>)
+ std::bool_constant<false>)
{
(void)sum_into_values_array;
Number *values_dofs,
FEEvaluationData<dim, Number, false> &fe_eval,
const bool sum_into_values_array,
- std::integral_constant<bool, true>)
+ std::bool_constant<true>)
{
T::integrate(n_components,
evaluation_flag,
values_dofs,
fe_eval,
sum_into_values_array,
- std::integral_constant<bool, do_integrate>());
+ std::bool_constant<do_integrate>());
}
};
has_hn_constraints = true;
}
- std::integral_constant<bool,
- internal::is_vectorizable<VectorType, Number>::value>
+ std::bool_constant<internal::is_vectorizable<VectorType, Number>::value>
vector_selector;
const bool use_vectorized_path =
// a vector and puts the data into the local data field or write local data
// into the vector. Certain operations are no-ops for the given use case.
- std::integral_constant<bool,
- internal::is_vectorizable<VectorType, Number>::value>
+ std::bool_constant<internal::is_vectorizable<VectorType, Number>::value>
vector_selector;
const internal::MatrixFreeFunctions::DoFInfo::DoFAccessIndex ind =
is_face ? this->dof_access_index :
template <typename VectorStruct>
unsigned int
- n_components_block(const VectorStruct &vec,
- std::integral_constant<bool, true>)
+ n_components_block(const VectorStruct &vec, const std::bool_constant<true>)
{
unsigned int components = 0;
for (unsigned int bl = 0; bl < vec.n_blocks(); ++bl)
template <typename VectorStruct>
unsigned int
- n_components_block(const VectorStruct &, std::integral_constant<bool, false>)
+ n_components_block(const VectorStruct &, const std::bool_constant<false>)
{
return 1;
}
n_components(const VectorStruct &vec)
{
return n_components_block(
- vec, std::integral_constant<bool, IsBlockVector<VectorStruct>::value>());
+ vec, std::bool_constant<IsBlockVector<VectorStruct>::value>());
}
template <typename VectorStruct>
unsigned int components = 0;
for (unsigned int comp = 0; comp < vec.size(); ++comp)
components += n_components_block(
- vec[comp],
- std::integral_constant<bool, IsBlockVector<VectorStruct>::value>());
+ vec[comp], std::bool_constant<IsBlockVector<VectorStruct>::value>());
return components;
}
unsigned int components = 0;
for (unsigned int comp = 0; comp < vec.size(); ++comp)
components += n_components_block(
- *vec[comp],
- std::integral_constant<bool, IsBlockVector<VectorStruct>::value>());
+ *vec[comp], std::bool_constant<IsBlockVector<VectorStruct>::value>());
return components;
}
// a dummy InVector == unsigned int is provided.
// Thus we have to treat this case as well.
template <class T, class IsSerialVectorNotSpecialized = void>
- using not_parallel_vector_t =
- std::integral_constant<bool, is_serial_vector<T>::value>;
+ using not_parallel_vector_t = std::bool_constant<is_serial_vector<T>::value>;
/**
* A predicate stating whether something is a vector type. We test this
const unsigned int dof_index,
VectorType &vec,
VectorizedArrayType *dof_values,
- std::integral_constant<bool, true>) const
+ std::bool_constant<true>) const
{
#ifdef DEBUG
// in debug mode, run non-vectorized version because this path
// has additional checks (e.g., regarding ghosting)
- process_dofs_vectorized(dofs_per_cell,
- dof_index,
- vec,
- dof_values,
- std::integral_constant<bool, false>());
+ process_dofs_vectorized(
+ dofs_per_cell, dof_index, vec, dof_values, std::bool_constant<false>());
#else
const Number *vec_ptr = vec.begin() + dof_index;
for (unsigned int i = 0; i < dofs_per_cell;
const unsigned int dof_index,
const VectorType &vec,
VectorizedArrayType *dof_values,
- std::integral_constant<bool, false>) const
+ std::bool_constant<false>) const
{
for (unsigned int i = 0; i < dofs_per_cell; ++i)
for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
VectorType &vec,
const unsigned int constant_offset,
VectorizedArrayType *dof_values,
- std::integral_constant<bool, true>) const
+ std::bool_constant<true>) const
{
dealii::vectorized_load_and_transpose(dofs_per_cell,
vec.begin() + constant_offset,
const VectorType &vec,
const unsigned int constant_offset,
VectorizedArrayType *dof_values,
- std::integral_constant<bool, false>) const
+ std::bool_constant<false>) const
{
for (unsigned int d = 0; d < dofs_per_cell; ++d)
for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
template <typename VectorType>
void
- process_dofs_vectorized_transpose(
- const unsigned int dofs_per_cell,
- const unsigned int *dof_indices,
- VectorType &vec,
- VectorizedArrayType *dof_values,
- std::integral_constant<bool, true> type) const
+ process_dofs_vectorized_transpose(const unsigned int dofs_per_cell,
+ const unsigned int *dof_indices,
+ VectorType &vec,
+ VectorizedArrayType *dof_values,
+ std::bool_constant<true> type) const
{
process_dofs_vectorized_transpose(
dofs_per_cell, dof_indices, vec, 0, dof_values, type);
template <typename VectorType>
void
- process_dofs_vectorized_transpose(
- const unsigned int dofs_per_cell,
- const unsigned int *dof_indices,
- const VectorType &vec,
- VectorizedArrayType *dof_values,
- std::integral_constant<bool, false> type) const
+ process_dofs_vectorized_transpose(const unsigned int dofs_per_cell,
+ const unsigned int *dof_indices,
+ const VectorType &vec,
+ VectorizedArrayType *dof_values,
+ std::bool_constant<false> type) const
{
process_dofs_vectorized_transpose(
dofs_per_cell, dof_indices, vec, 0, dof_values, type);
const unsigned int dofs_per_cell,
const std::array<Number2 *, VectorizedArrayType::size()> &global_ptr,
VectorizedArrayType *dof_values,
- std::integral_constant<bool, true>) const
+ std::bool_constant<true>) const
{
dealii::vectorized_load_and_transpose(dofs_per_cell,
global_ptr,
const unsigned int,
const std::array<Number2 *, VectorizedArrayType::size()> &,
VectorizedArrayType *,
- std::integral_constant<bool, false>) const
+ std::bool_constant<false>) const
{
Assert(false, ExcNotImplemented());
}
const unsigned int constant_offset,
typename VectorType::value_type *vec_ptr,
VectorizedArrayType &res,
- std::integral_constant<bool, true>) const
+ std::bool_constant<true>) const
{
(void)constant_offset;
(void)vec;
constant_offset,
vec_ptr,
res,
- std::integral_constant<bool, false>());
+ std::bool_constant<false>());
#else
res.gather(vec_ptr, indices);
#endif
const unsigned int constant_offset,
typename VectorType::value_type *,
VectorizedArrayType &res,
- std::integral_constant<bool, false>) const
+ std::bool_constant<false>) const
{
for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
res[v] = vector_access(vec, indices[v] + constant_offset);
const unsigned int dof_index,
VectorType &vec,
VectorizedArrayType *dof_values,
- std::integral_constant<bool, true>) const
+ std::bool_constant<true>) const
{
Number *vec_ptr = vec.begin() + dof_index;
for (unsigned int i = 0; i < dofs_per_cell;
const unsigned int dof_index,
VectorType &vec,
VectorizedArrayType *dof_values,
- std::integral_constant<bool, false>) const
+ std::bool_constant<false>) const
{
for (unsigned int i = 0; i < dofs_per_cell; ++i)
for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
VectorType &vec,
const unsigned int constant_offset,
VectorizedArrayType *dof_values,
- std::integral_constant<bool, true>) const
+ std::bool_constant<true>) const
{
vectorized_transpose_and_store(true,
dofs_per_cell,
VectorType &vec,
const unsigned int constant_offset,
VectorizedArrayType *dof_values,
- std::integral_constant<bool, false>) const
+ std::bool_constant<false>) const
{
for (unsigned int d = 0; d < dofs_per_cell; ++d)
for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
template <typename VectorType>
void
- process_dofs_vectorized_transpose(
- const unsigned int dofs_per_cell,
- const unsigned int *dof_indices,
- VectorType &vec,
- VectorizedArrayType *dof_values,
- std::integral_constant<bool, true> type) const
+ process_dofs_vectorized_transpose(const unsigned int dofs_per_cell,
+ const unsigned int *dof_indices,
+ VectorType &vec,
+ VectorizedArrayType *dof_values,
+ std::bool_constant<true> type) const
{
process_dofs_vectorized_transpose(
dofs_per_cell, dof_indices, vec, 0, dof_values, type);
template <typename VectorType>
void
- process_dofs_vectorized_transpose(
- const unsigned int dofs_per_cell,
- const unsigned int *dof_indices,
- VectorType &vec,
- VectorizedArrayType *dof_values,
- std::integral_constant<bool, false> type) const
+ process_dofs_vectorized_transpose(const unsigned int dofs_per_cell,
+ const unsigned int *dof_indices,
+ VectorType &vec,
+ VectorizedArrayType *dof_values,
+ std::bool_constant<false> type) const
{
process_dofs_vectorized_transpose(
dofs_per_cell, dof_indices, vec, 0, dof_values, type);
const unsigned int dofs_per_cell,
std::array<Number2 *, VectorizedArrayType::size()> &global_ptr,
VectorizedArrayType *dof_values,
- std::integral_constant<bool, true>) const
+ std::bool_constant<true>) const
{
vectorized_transpose_and_store(true,
dofs_per_cell,
const unsigned int,
std::array<Number2 *, VectorizedArrayType::size()> &,
VectorizedArrayType *,
- std::integral_constant<bool, false>) const
+ std::bool_constant<false>) const
{
Assert(false, ExcNotImplemented());
}
const unsigned int constant_offset,
typename VectorType::value_type *vec_ptr,
VectorizedArrayType &res,
- std::integral_constant<bool, true>) const
+ std::bool_constant<true>) const
{
(void)constant_offset;
(void)vec_ptr;
const unsigned int constant_offset,
typename VectorType::value_type *,
VectorizedArrayType &res,
- std::integral_constant<bool, false>) const
+ std::bool_constant<false>) const
{
for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
vector_access_add(vec, indices[v] + constant_offset, res[v]);
const unsigned int dof_index,
VectorType &vec,
VectorizedArrayType *dof_values,
- std::integral_constant<bool, true>) const
+ std::bool_constant<true>) const
{
Number *vec_ptr = vec.begin() + dof_index;
for (unsigned int i = 0; i < dofs_per_cell;
const unsigned int dof_index,
VectorType &vec,
VectorizedArrayType *dof_values,
- std::integral_constant<bool, false>) const
+ std::bool_constant<false>) const
{
for (unsigned int i = 0; i < dofs_per_cell; ++i)
for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
VectorType &vec,
const unsigned int constant_offset,
VectorizedArrayType *dof_values,
- std::integral_constant<bool, true>) const
+ std::bool_constant<true>) const
{
vectorized_transpose_and_store(false,
dofs_per_cell,
VectorType &vec,
const unsigned int constant_offset,
VectorizedArrayType *dof_values,
- std::integral_constant<bool, false>) const
+ std::bool_constant<false>) const
{
for (unsigned int i = 0; i < dofs_per_cell; ++i)
for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
template <typename VectorType>
void
- process_dofs_vectorized_transpose(
- const unsigned int dofs_per_cell,
- const unsigned int *dof_indices,
- VectorType &vec,
- VectorizedArrayType *dof_values,
- std::integral_constant<bool, true> type) const
+ process_dofs_vectorized_transpose(const unsigned int dofs_per_cell,
+ const unsigned int *dof_indices,
+ VectorType &vec,
+ VectorizedArrayType *dof_values,
+ std::bool_constant<true> type) const
{
process_dofs_vectorized_transpose(
dofs_per_cell, dof_indices, vec, 0, dof_values, type);
template <typename VectorType, bool booltype>
void
- process_dofs_vectorized_transpose(
- const unsigned int dofs_per_cell,
- const unsigned int *dof_indices,
- VectorType &vec,
- VectorizedArrayType *dof_values,
- std::integral_constant<bool, false> type) const
+ process_dofs_vectorized_transpose(const unsigned int dofs_per_cell,
+ const unsigned int *dof_indices,
+ VectorType &vec,
+ VectorizedArrayType *dof_values,
+ std::bool_constant<false> type) const
{
process_dofs_vectorized_transpose(
dofs_per_cell, dof_indices, vec, 0, dof_values, type);
const unsigned int dofs_per_cell,
std::array<Number2 *, VectorizedArrayType::size()> &global_ptr,
VectorizedArrayType *dof_values,
- std::integral_constant<bool, true>) const
+ std::bool_constant<true>) const
{
vectorized_transpose_and_store(false,
dofs_per_cell,
const unsigned int,
std::array<Number2 *, VectorizedArrayType::size()> &,
VectorizedArrayType *,
- std::integral_constant<bool, false>) const
+ std::bool_constant<false>) const
{
Assert(false, ExcNotImplemented());
}
const unsigned int constant_offset,
typename VectorType::value_type *vec_ptr,
VectorizedArrayType &res,
- std::integral_constant<bool, true>) const
+ std::bool_constant<true>) const
{
(void)vec_ptr;
(void)constant_offset;
const unsigned int constant_offset,
typename VectorType::value_type *,
VectorizedArrayType &res,
- std::integral_constant<bool, false>) const
+ std::bool_constant<false>) const
{
for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
vector_access(vec, indices[v] + constant_offset) = res[v];
MatrixType &, \
VectorType &, \
bool, \
- std::integral_constant<bool, false>) const
+ std::bool_constant<false>) const
#define INSTANTIATE_DLTG_BLOCK_VECTORMATRIX(MatrixType, VectorType) \
template void AffineConstraints<MatrixType::value_type>:: \
MatrixType &, \
VectorType &, \
bool, \
- std::integral_constant<bool, true>) const
+ std::bool_constant<true>) const
#define INSTANTIATE_DLTG_MATRIX(MatrixType) \
template void \
M<S> &,
Vector<S> &,
bool,
- std::integral_constant<bool, false>) const;
+ std::bool_constant<false>) const;
template void AffineConstraints<S>::distribute_local_to_global<M<S>>(
const FullMatrix<S> &,
DiagonalMatrix<T<S>> &,
T<S> &,
bool,
- std::integral_constant<bool, false>) const;
+ std::bool_constant<false>) const;
template void AffineConstraints<S>::distribute_local_to_global<
DiagonalMatrix<LinearAlgebra::distributed::T<S>>,
DiagonalMatrix<LinearAlgebra::distributed::T<S>> &,
LinearAlgebra::distributed::T<S> &,
bool,
- std::integral_constant<bool, false>) const;
+ std::bool_constant<false>) const;
template void AffineConstraints<S>::distribute_local_to_global<
DiagonalMatrix<LinearAlgebra::distributed::T<S>>,
DiagonalMatrix<LinearAlgebra::distributed::T<S>> &,
T<S> &,
bool,
- std::integral_constant<bool, false>) const;
+ std::bool_constant<false>) const;
}
// BlockSparseMatrix:
BlockSparseMatrix<S> &,
Vector<S> &,
bool,
- std::integral_constant<bool, true>) const;
+ std::bool_constant<true>) const;
template void AffineConstraints<S>::distribute_local_to_global<
BlockSparseMatrix<S>,
BlockSparseMatrix<S> &,
BlockVector<S> &,
bool,
- std::integral_constant<bool, true>) const;
+ std::bool_constant<true>) const;
template void
AffineConstraints<S>::distribute_local_to_global<BlockSparseMatrix<S>>(
projects / dealii.git / commitdiff