+#ifndef DOXYGEN
IndexSet IndexSet::operator&(const IndexSet &is) const
{
Assert(size() == is.size(), ExcDimensionMismatch(size(), is.size()));
result.compress();
return result;
}
+#endif
# ifdef DEAL_II_WITH_ADOLC
+# ifndef DOXYGEN
// Specialization for taped ADOL-C auto-differentiable numbers.
template <typename ADNumberType>
, vbufsize(0u)
, tbufsize(0u)
{}
+# endif
template <typename ADNumberType>
}
+# ifndef DOXYGEN
template <typename ADNumberType>
std::vector<double>
TapedDrivers<
std::copy(in.begin(), in.end(), out.begin());
return out;
}
+# endif
// ------------- TapelessDrivers -------------
// reverse mode to compute the first derivatives (and, if supported,
// forward mode for the second).
+# ifndef DOXYGEN
template <typename ADNumberType, typename ScalarType>
TapelessDrivers<
ADNumberType,
NumberTypes::sacado_rad_dfad>::type>::TapelessDrivers()
: dependent_variable_marking_safe(false)
{}
+# endif
template <typename ADNumberType, typename ScalarType>
// forward mode to compute the first (and, if supported, second)
// derivatives.
+# ifndef DOXYGEN
template <typename ADNumberType, typename ScalarType>
TapelessDrivers<
ADNumberType,
NumberTypes::sacado_dfad_dfad>::type>::TapelessDrivers()
: dependent_variable_marking_safe(false)
{}
+# endif
template <typename ADNumberType, typename ScalarType>
/* ---------------- Symbol map creation and manipulation --------------*/
+# ifndef DOXYGEN
namespace internal
{
bool
for (const auto &entry : symbol_values)
set_value_in_symbol_map(substitution_map, entry.first, entry.second);
}
+# endif
/* ------------------ Symbol substitution map creation ----------------*/
}
+# ifndef DOXYGEN
/* ---------------- Symbolic substitution map enlargement --------------*/
{
return expression.substitute(substitution_map);
}
+# endif // DOXYGEN
} // namespace SD
} // namespace Differentiation
}
+# ifndef DOXYGEN
template <int dim>
Tensor<1, dim, Expression>
make_vector_of_symbolic_functions(const std::string & sym,
{
return internal::Symbol_Function_Tensor<1, dim>::create(sym, arguments);
}
+# endif
template <int rank, int dim>
}
+# ifndef DOXYGEN
template <int rank, int dim>
Tensor<rank, dim, Expression>
make_tensor_of_symbolic_functions(const std::string & sym,
return internal::Symbol_Function_SymmetricTensor<rank, dim>::create(
sym, arguments);
}
+# endif // DOXYGEN
} // namespace SD
} // namespace Differentiation
namespace Utilities
{
+# ifndef DOXYGEN
SE::map_basic_basic
convert_expression_map_to_basic_map(
const SD::types::substitution_map &substitution_map)
sub_map[entry.first.get_RCP()] = entry.second.get_RCP();
return sub_map;
}
+# endif
SE::vec_basic
}
+# ifndef DOXYGEN
SD::types::symbol_vector
extract_symbols(const SD::types::substitution_map &substitution_values)
{
return symbols;
}
+# endif
} // namespace Utilities
// explicit instantiations
+#ifndef DOXYGEN
template class TriaObjects<TriaObject<1>>;
template class TriaObjects<TriaObject<2>>;
-#include "tria_objects.inst"
+# include "tria_objects.inst"
+#endif
} // namespace TriangulationImplementation
} // namespace internal
}
+#ifndef DOXYGEN
template <>
void
BlockSparsityPatternBase<DynamicSparsityPattern>::print(std::ostream &out) const
k += block(ib, 0).n_rows();
}
}
+#endif
template <class SparsityPatternBase>
{
namespace MatrixIterators
{
+# ifndef DOXYGEN
void
MatrixBase::const_iterator::Accessor::visit_present_row()
{
ierr = MatRestoreRow(*matrix, this->a_row, &ncols, &colnums, &values);
AssertThrow(ierr == 0, ExcPETScError(ierr));
}
+# endif
} // namespace MatrixIterators
}
}
+# ifndef DOXYGEN
// explicit instantiations
//
template SparseMatrix::SparseMatrix(const MPI_Comm &,
SparseMatrix::do_reinit(const IndexSet &,
const IndexSet &,
const DynamicSparsityPattern &);
+# endif
PetscScalar
MatrixBase::Tmmult(C, B, V);
}
+# ifndef DOXYGEN
// Explicit instantiations
//
template SparseMatrix::SparseMatrix(const SparsityPattern &, const bool);
SparseMatrix::do_reinit(const SparsityPattern &, const bool);
template void
SparseMatrix::do_reinit(const DynamicSparsityPattern &, const bool);
+# endif
} // namespace PETScWrappers
{
namespace internal
{
+# ifndef DOXYGEN
VectorReference::operator PetscScalar() const
{
AssertIndexRange(index, vector.size());
return value;
}
+# endif
} // namespace internal
VectorBase::VectorBase()
#undef TEMPL_COPY_CONSTRUCTOR
+#ifndef DOXYGEN
template void
ReadWriteVector<float>::import(
const distributed::Vector<float, ::dealii::MemorySpace::Host> &,
const distributed::Vector<double, ::dealii::MemorySpace::Host> &,
VectorOperation::values,
const std::shared_ptr<const CommunicationPatternBase> &);
-#ifdef DEAL_II_WITH_COMPLEX_VALUES
+# ifdef DEAL_II_WITH_COMPLEX_VALUES
template void
ReadWriteVector<std::complex<float>>::import(
const distributed::Vector<std::complex<float>, ::dealii::MemorySpace::Host>
&,
VectorOperation::values,
const std::shared_ptr<const CommunicationPatternBase> &);
+# endif
#endif
} // namespace LinearAlgebra
+#ifndef DOXYGEN
// explicit instantiations
template void
SparsityPattern::copy_from<float>(const FullMatrix<float> &);
const size_type *,
const size_type *,
const bool);
-#ifndef DEAL_II_VECTOR_ITERATOR_IS_POINTER
+# ifndef DEAL_II_VECTOR_ITERATOR_IS_POINTER
template void
SparsityPattern::add_entries<
std::vector<SparsityPattern::size_type>::const_iterator>(
std::vector<size_type>::const_iterator,
std::vector<size_type>::const_iterator,
const bool);
-#endif
+# endif
template void
SparsityPattern::add_entries<std::vector<SparsityPattern::size_type>::iterator>(
const size_type,
std::vector<size_type>::iterator,
std::vector<size_type>::iterator,
const bool);
+#endif
DEAL_II_NAMESPACE_CLOSE
+# ifndef DOXYGEN
void
BlockSparseMatrix::reinit(const size_type n_block_rows,
const size_type n_block_columns)
this->sub_objects[r][c] = p;
}
}
+# endif
+# ifndef DOXYGEN
// -------------------- explicit instantiations -----------------------
//
template void
const dealii::BlockDynamicSparsityPattern &,
const MPI_Comm &,
const bool);
+# endif // DOXYGEN
} // namespace TrilinosWrappers
dst = src;
}
+# ifndef DOXYGEN
void
PreconditionIdentity::vmult(
LinearAlgebra::distributed::Vector<double> & dst,
{
dst = src;
}
+# endif // DOXYGEN
} // namespace TrilinosWrappers
DEAL_II_NAMESPACE_CLOSE
+# ifndef DOXYGEN
// explicit instantiations
template void
PreconditionAMG::initialize(const ::dealii::SparseMatrix<double> &,
const AdditionalData &,
const double,
const ::dealii::SparsityPattern *);
+# endif
+# ifndef DOXYGEN
// explicit instantiations
template void
PreconditionAMGMueLu::initialize(const ::dealii::SparseMatrix<double> &,
const AdditionalData &,
const double,
const ::dealii::SparsityPattern *);
+# endif
} // namespace TrilinosWrappers
}
+# ifndef DOXYGEN
// explicit instantiations
//
template void
const dealii::DynamicSparsityPattern &,
const MPI_Comm &,
bool);
+# endif
} // namespace TrilinosWrappers
namespace TrilinosWrappers
{
+# ifndef DOXYGEN
namespace internal
{
VectorReference::operator TrilinosScalar() const
return (*(vector.vector))[0][local_index];
}
} // namespace internal
+# endif
namespace MPI
{
this->local_size() *
(sizeof(double) + sizeof(TrilinosWrappers::types::int_type));
}
- } /* end of namespace MPI */
-} /* end of namespace TrilinosWrappers */
-namespace TrilinosWrappers
-{
- namespace MPI
- {
-# include "trilinos_vector.inst"
- }
+ // explicit instantiations
+# ifndef DOXYGEN
+# include "trilinos_vector.inst"
+# endif
+ } // namespace MPI
} // namespace TrilinosWrappers
DEAL_II_NAMESPACE_CLOSE
DEAL_II_NAMESPACE_OPEN
-#include "vector.inst"
+#ifndef DOXYGEN
+# include "vector.inst"
-#ifndef DEAL_II_WITH_COMPLEX_VALUES
+# ifndef DEAL_II_WITH_COMPLEX_VALUES
// instantiate for std::complex<double> since we are using it internally in
// FESeries.
template class Vector<std::complex<double>>;
-#endif
+# endif
// instantiate for integers:
template class Vector<int>;
// arguments is covered by the default copy constructor and copy operator that
// is declared separately)
-#define TEMPL_COPY_CONSTRUCTOR(S1, S2) \
- template Vector<S1>::Vector(const Vector<S2> &); \
- template Vector<S1> &Vector<S1>::operator=<S2>(const Vector<S2> &)
+# define TEMPL_COPY_CONSTRUCTOR(S1, S2) \
+ template Vector<S1>::Vector(const Vector<S2> &); \
+ template Vector<S1> &Vector<S1>::operator=<S2>(const Vector<S2> &)
TEMPL_COPY_CONSTRUCTOR(double, float);
TEMPL_COPY_CONSTRUCTOR(float, double);
-#ifdef DEAL_II_WITH_COMPLEX_VALUES
+# ifdef DEAL_II_WITH_COMPLEX_VALUES
TEMPL_COPY_CONSTRUCTOR(std::complex<double>, std::complex<float>);
TEMPL_COPY_CONSTRUCTOR(std::complex<float>, std::complex<double>);
-#endif
+# endif
-#undef TEMPL_COPY_CONSTRUCTOR
+# undef TEMPL_COPY_CONSTRUCTOR
-#define TEMPL_OP_EQ(S1, S2) \
- template void Vector<S1>::scale(const Vector<S2> &); \
- template void Vector<S1>::equ(const S1, const Vector<S2> &)
+# define TEMPL_OP_EQ(S1, S2) \
+ template void Vector<S1>::scale(const Vector<S2> &); \
+ template void Vector<S1>::equ(const S1, const Vector<S2> &)
TEMPL_OP_EQ(double, float);
TEMPL_OP_EQ(float, double);
-#ifdef DEAL_II_WITH_COMPLEX_VALUES
+# ifdef DEAL_II_WITH_COMPLEX_VALUES
TEMPL_OP_EQ(std::complex<double>, std::complex<float>);
TEMPL_OP_EQ(std::complex<float>, std::complex<double>);
-#endif
-
-#undef TEMPL_OP_EQ
+# endif
+# undef TEMPL_OP_EQ
+#endif
template <>
+#ifndef DOXYGEN
template <int dim>
TimeStepBase_Tria<dim>::TimeStepBase_Tria(
const double time,
, flags(flags)
, refinement_flags(refinement_flags)
{}
+#endif