*/
BlockIndices (const std::vector<size_type> &block_sizes);
-#ifdef DEAL_II_WITH_CXX11
/**
* Move constructor. Initialize a new object by stealing the internal data of
* another BlockIndices object.
- *
- * @note This constructor is only available if deal.II is configured with
- * C++11 support.
*/
BlockIndices (BlockIndices &&b);
* Copy constructor.
*/
BlockIndices (const BlockIndices &) = default;
-#endif
/**
* Specialized constructor for a structure with blocks of equal size.
*/
BlockIndices &operator = (const BlockIndices &b);
-#ifdef DEAL_II_WITH_CXX11
/**
* Move assignment operator. Move another BlockIndices object onto the
* current one by transferring its contents.
*/
BlockIndices &operator = (BlockIndices &&);
-#endif
/**
* Compare whether two objects are the same, i.e. whether the number of
-#ifdef DEAL_II_WITH_CXX11
-
inline
BlockIndices::BlockIndices (BlockIndices &&b)
:
b.start_indices = std::vector<size_type>(1, 0);
}
-#endif
-
inline
-#ifdef DEAL_II_WITH_CXX11
inline
BlockIndices &
BlockIndices::operator = (BlockIndices &&b)
return *this;
}
-#endif
#include <deal.II/lac/linear_operator.h>
-#ifdef DEAL_II_WITH_CXX11
DEAL_II_NAMESPACE_OPEN
* sizes, and small block structure (as a rule of thumb, matrix blocks greater
* than $1000\times1000$).
*
- * @note This class is only available if deal.II was configured with C++11
- * support, i.e., if <code>DEAL_II_WITH_CXX11</code> is enabled during cmake
- * configure.
- *
* @author Matthias Maier, 2015
*
* @ingroup LAOperators
DEAL_II_NAMESPACE_CLOSE
-#endif // DEAL_II_WITH_CXX11
#endif
BlockVector (const BlockVector<Number> &V);
-#ifdef DEAL_II_WITH_CXX11
/**
* Move constructor. Creates a new vector by stealing the internal data of
* the given argument vector.
- *
- * @note This constructor is only available if deal.II is configured with
- * C++11 support.
*/
BlockVector (BlockVector<Number> &&/*v*/) = default;
-#endif
#ifndef DEAL_II_EXPLICIT_CONSTRUCTOR_BUG
BlockVector<Number> &
operator= (const BlockVector<Number> &v);
-#ifdef DEAL_II_WITH_CXX11
/**
* Move the given vector. This operator replaces the present vector with
* the contents of the given argument vector.
- *
- * @note This operator is only available if deal.II is configured with C++11
- * support.
*/
BlockVector<Number> &operator= (BlockVector<Number> &&/*v*/) = default;
-#endif
/**
* Copy operator for template arguments of different types. Resize the
* Copy constructor from an iterator of different constness.
*
* @note Constructing a non-const iterator from a const iterator does
- * not make sense. If deal.II was configured with C++11 support, then
- * attempting this will result in a compile-time error (via
- * <code>static_assert</code>). If deal.II was not configured with C++11
- * support, then attempting this will result in a thrown exception in
- * debug mode.
+ * not make sense. Attempting this will result in a compile-time error
+ * (via <code>static_assert</code>).
*/
Iterator (const Iterator<BlockVectorType,!Constness> &c);
"different block vectors. There is no reasonable way "
"to do this.");
- /**
- * Exception thrown when one attempts to copy construct a non-const
- * iterator from a const iterator.
- *
- * @note when deal.II is compiled with C++11 support this check is
- * instead performed at compile time via <code>static_assert</code>.
- */
- DeclExceptionMsg (ExcCastingAwayConstness,
- "Constructing a non-const iterator from a const "
- "iterator does not make sense.");
//@}
private:
/**
*/
BlockVectorBase ();
-#ifdef DEAL_II_WITH_CXX11
/**
* Copy constructor.
*/
* Move constructor. Each block of the argument vector is moved into the current
* object if the underlying <code>VectorType</code> is move-constructible,
* otherwise they are copied.
- *
- * @note This constructor is only available if deal.II is configured with
- * C++11 support.
*/
BlockVectorBase (BlockVectorBase &&/*V*/) = default;
-#endif
/**
* Update internal structures after resizing vectors. Whenever you reinited
BlockVectorBase &
operator= (const BlockVectorBase &V);
-#ifdef DEAL_II_WITH_CXX11
/**
* Move assignment operator. Move each block of the given argument
* vector into the current object if `VectorType` is
* move-constructible, otherwise copy them.
*/
BlockVectorBase &operator= (BlockVectorBase &&/*V*/) = default;
-#endif
/**
* Copy operator for template arguments of different types.
// iterators, and not vice versa (i.e., Constness must always be
// true). As mentioned above, try to check this at compile time if C++11
// support is available.
-#ifdef DEAL_II_WITH_CXX11
static_assert(Constness == true,
"Constructing a non-const iterator from a const iterator "
"does not make sense.");
-#else
- Assert(Constness == true, ExcCastingAwayConstness());
-#endif
}
#include <deal.II/lac/packaged_operation.h>
#include <deal.II/lac/constraint_matrix.h>
-#ifdef DEAL_II_WITH_CXX11
DEAL_II_NAMESPACE_OPEN
DEAL_II_NAMESPACE_CLOSE
-#endif // DEAL_II_WITH_CXX11
#endif
* from machine accuracy, even if the errors of the outer loop are in the
* range of machine accuracy.
*
- * @deprecated If deal.II was configured with C++11 support, use the
- * LinearOperator class instead, see the module on
- * @ref LAOperators "linear operators"
- * for further details.
+ * @deprecated Use the LinearOperator class instead. See the module on
+ * @ref LAOperators "linear operators" for further details.
*
* @ingroup Matrix2
* @author Guido Kanschat
#include <deal.II/base/exceptions.h>
#include <deal.II/lac/vector_memory.h>
-#ifdef DEAL_II_WITH_CXX11
-
#include <array>
#include <functional>
#include <type_traits>
* for linear operators have been provided within the respective
* TrilinosWrappers (and, in the future, PetscWrappers) namespaces.
*
- * @note This class is only available if deal.II was configured with C++11
- * support, i.e., if <code>DEAL_II_WITH_CXX11</code> is enabled during cmake
- * configure.
- *
* @author Luca Heltai, Matthias Maier, 2015; Jean-Paul Pelteret, 2016
*
* @ingroup LAOperators
DEAL_II_NAMESPACE_CLOSE
-#endif // DEAL_II_WITH_CXX11
#endif
#include <deal.II/base/exceptions.h>
#include <deal.II/lac/vector_memory.h>
-#ifdef DEAL_II_WITH_CXX11
-
#include <functional>
DEAL_II_NAMESPACE_OPEN
DEAL_II_NAMESPACE_CLOSE
-#endif // DEAL_II_WITH_CXX11
#endif
inline void
PreconditionRichardson::vmult (VectorType &dst, const VectorType &src) const
{
-#ifdef DEAL_II_WITH_CXX11
static_assert(
std::is_same<size_type, typename VectorType::size_type>::value,
"PreconditionRichardson and VectorType must have the same size_type.");
-#endif // DEAL_II_WITH_CXX11
dst.equ(relaxation,src);
}
inline void
PreconditionRichardson::Tvmult (VectorType &dst, const VectorType &src) const
{
-#ifdef DEAL_II_WITH_CXX11
static_assert(
std::is_same<size_type, typename VectorType::size_type>::value,
"PreconditionRichardson and VectorType must have the same size_type.");
-#endif // DEAL_II_WITH_CXX11
dst.equ(relaxation,src);
}
inline void
PreconditionRichardson::vmult_add (VectorType &dst, const VectorType &src) const
{
-#ifdef DEAL_II_WITH_CXX11
static_assert(
std::is_same<size_type, typename VectorType::size_type>::value,
"PreconditionRichardson and VectorType must have the same size_type.");
-#endif // DEAL_II_WITH_CXX11
dst.add(relaxation,src);
}
inline void
PreconditionRichardson::Tvmult_add (VectorType &dst, const VectorType &src) const
{
-#ifdef DEAL_II_WITH_CXX11
static_assert(
std::is_same<size_type, typename VectorType::size_type>::value,
"PreconditionRichardson and VectorType must have the same size_type.");
-#endif // DEAL_II_WITH_CXX11
dst.add(relaxation,src);
}
inline void
PreconditionJacobi<MatrixType>::vmult (VectorType &dst, const VectorType &src) const
{
-#ifdef DEAL_II_WITH_CXX11
static_assert(
std::is_same<typename PreconditionJacobi<MatrixType>::size_type, typename VectorType::size_type>::value,
"PreconditionJacobi and VectorType must have the same size_type.");
-#endif // DEAL_II_WITH_CXX11
Assert (this->A!=nullptr, ExcNotInitialized());
this->A->precondition_Jacobi (dst, src, this->relaxation);
inline void
PreconditionJacobi<MatrixType>::Tvmult (VectorType &dst, const VectorType &src) const
{
-#ifdef DEAL_II_WITH_CXX11
static_assert(
std::is_same<typename PreconditionJacobi<MatrixType>::size_type, typename VectorType::size_type>::value,
"PreconditionJacobi and VectorType must have the same size_type.");
-#endif // DEAL_II_WITH_CXX11
Assert (this->A!=nullptr, ExcNotInitialized());
this->A->precondition_Jacobi (dst, src, this->relaxation);
inline void
PreconditionJacobi<MatrixType>::step (VectorType &dst, const VectorType &src) const
{
-#ifdef DEAL_II_WITH_CXX11
static_assert(
std::is_same<typename PreconditionJacobi<MatrixType>::size_type, typename VectorType::size_type>::value,
"PreconditionJacobi and VectorType must have the same size_type.");
-#endif // DEAL_II_WITH_CXX11
Assert (this->A!=nullptr, ExcNotInitialized());
this->A->Jacobi_step (dst, src, this->relaxation);
inline void
PreconditionJacobi<MatrixType>::Tstep (VectorType &dst, const VectorType &src) const
{
-#ifdef DEAL_II_WITH_CXX11
static_assert(
std::is_same<typename PreconditionJacobi<MatrixType>::size_type, typename VectorType::size_type>::value,
"PreconditionJacobi and VectorType must have the same size_type.");
-#endif // DEAL_II_WITH_CXX11
step (dst, src);
}
inline void
PreconditionSOR<MatrixType>::vmult (VectorType &dst, const VectorType &src) const
{
-#ifdef DEAL_II_WITH_CXX11
static_assert(
std::is_same<typename PreconditionSOR<MatrixType>::size_type, typename VectorType::size_type>::value,
"PreconditionSOR and VectorType must have the same size_type.");
-#endif // DEAL_II_WITH_CXX11
Assert (this->A!=nullptr, ExcNotInitialized());
this->A->precondition_SOR (dst, src, this->relaxation);
inline void
PreconditionSOR<MatrixType>::Tvmult (VectorType &dst, const VectorType &src) const
{
-#ifdef DEAL_II_WITH_CXX11
static_assert(
std::is_same<typename PreconditionSOR<MatrixType>::size_type, typename VectorType::size_type>::value,
"PreconditionSOR and VectorType must have the same size_type.");
-#endif // DEAL_II_WITH_CXX11
Assert (this->A!=nullptr, ExcNotInitialized());
this->A->precondition_TSOR (dst, src, this->relaxation);
inline void
PreconditionSOR<MatrixType>::step (VectorType &dst, const VectorType &src) const
{
-#ifdef DEAL_II_WITH_CXX11
static_assert(
std::is_same<typename PreconditionSOR<MatrixType>::size_type, typename VectorType::size_type>::value,
"PreconditionSOR and VectorType must have the same size_type.");
-#endif // DEAL_II_WITH_CXX11
Assert (this->A!=nullptr, ExcNotInitialized());
this->A->SOR_step (dst, src, this->relaxation);
inline void
PreconditionSOR<MatrixType>::Tstep (VectorType &dst, const VectorType &src) const
{
-#ifdef DEAL_II_WITH_CXX11
static_assert(
std::is_same<typename PreconditionSOR<MatrixType>::size_type, typename VectorType::size_type>::value,
"PreconditionSOR and VectorType must have the same size_type.");
-#endif // DEAL_II_WITH_CXX11
Assert (this->A!=nullptr, ExcNotInitialized());
this->A->TSOR_step (dst, src, this->relaxation);
inline void
PreconditionSSOR<MatrixType>::vmult (VectorType &dst, const VectorType &src) const
{
-#ifdef DEAL_II_WITH_CXX11
static_assert(
std::is_same<typename PreconditionSSOR<MatrixType>::size_type, typename VectorType::size_type>::value,
"PreconditionSSOR and VectorType must have the same size_type.");
-#endif // DEAL_II_WITH_CXX11
Assert (this->A!=nullptr, ExcNotInitialized());
this->A->precondition_SSOR (dst, src, this->relaxation, pos_right_of_diagonal);
inline void
PreconditionSSOR<MatrixType>::Tvmult (VectorType &dst, const VectorType &src) const
{
-#ifdef DEAL_II_WITH_CXX11
static_assert(
std::is_same<typename PreconditionSSOR<MatrixType>::size_type, typename VectorType::size_type>::value,
"PreconditionSSOR and VectorType must have the same size_type.");
-#endif // DEAL_II_WITH_CXX11
Assert (this->A!=nullptr, ExcNotInitialized());
this->A->precondition_SSOR (dst, src, this->relaxation, pos_right_of_diagonal);
inline void
PreconditionSSOR<MatrixType>::step (VectorType &dst, const VectorType &src) const
{
-#ifdef DEAL_II_WITH_CXX11
static_assert(
std::is_same<typename PreconditionSSOR<MatrixType>::size_type, typename VectorType::size_type>::value,
"PreconditionSSOR and VectorType must have the same size_type.");
-#endif // DEAL_II_WITH_CXX11
Assert (this->A!=nullptr, ExcNotInitialized());
this->A->SSOR_step (dst, src, this->relaxation);
inline void
PreconditionSSOR<MatrixType>::Tstep (VectorType &dst, const VectorType &src) const
{
-#ifdef DEAL_II_WITH_CXX11
static_assert(
std::is_same<typename PreconditionSSOR<MatrixType>::size_type, typename VectorType::size_type>::value,
"PreconditionSSOR and VectorType must have the same size_type.");
-#endif // DEAL_II_WITH_CXX11
step (dst, src);
}
inline void
PreconditionPSOR<MatrixType>::vmult (VectorType &dst, const VectorType &src) const
{
-#ifdef DEAL_II_WITH_CXX11
static_assert(
std::is_same<typename PreconditionPSOR<MatrixType>::size_type, typename VectorType::size_type>::value,
"PreconditionPSOR and VectorType must have the same size_type.");
-#endif // DEAL_II_WITH_CXX11
Assert (this->A!=nullptr, ExcNotInitialized());
dst = src;
inline void
PreconditionPSOR<MatrixType>::Tvmult (VectorType &dst, const VectorType &src) const
{
-#ifdef DEAL_II_WITH_CXX11
static_assert(
std::is_same<typename PreconditionPSOR<MatrixType>::size_type, typename VectorType::size_type>::value,
"PreconditionPSOR and VectorType must have the same size_type.");
-#endif // DEAL_II_WITH_CXX11
Assert (this->A!=nullptr, ExcNotInitialized());
dst = src;
delta (1.),
is_initialized (false)
{
-#ifdef DEAL_II_WITH_CXX11
static_assert(
std::is_same<size_type, typename VectorType::size_type>::value,
"PreconditionChebyshev and VectorType must have the same size_type.");
-#endif // DEAL_II_WITH_CXX11
}
virtual void reinit (const IndexSet &locally_stored_indices,
const bool omit_zeroing_entries = false);
-#ifdef DEAL_II_WITH_CXX11
/**
* Apply the functor @p func to each element of the vector. The functor
* should look like
*/
template <typename Functor>
void apply(const Functor &func);
-#endif
/**
* Swap the contents of this vector and the other vector @p v. One could
*/
template <typename Number2> friend class ReadWriteVector;
-#ifdef DEAL_II_WITH_CXX11
private:
/**
* This class provides a wrapper around a Functor which acts on
*/
const Functor &functor;
};
-#endif
};
/*@}*/
-#ifdef DEAL_II_WITH_CXX11
template <typename Number>
template <typename Functor>
inline
for (size_type i=begin; i<end; ++i)
functor(parent.val[i]);
}
-#endif
#endif // ifndef DOXYGEN
-#ifdef DEAL_II_WITH_CXX11
template <typename Number>
template <typename Functor>
void
FunctorTemplate<Functor> functor(*this, func);
internal::VectorOperations::parallel_for(functor, 0, n_elements(), thread_loop_partitioner);
}
-#endif
#include <deal.II/lac/linear_operator.h>
#include <deal.II/lac/packaged_operation.h>
-#ifdef DEAL_II_WITH_CXX11
DEAL_II_NAMESPACE_OPEN
DEAL_II_NAMESPACE_CLOSE
-#endif // DEAL_II_WITH_CXX11
#endif
*/
SparseMatrix (const SparseMatrix &);
-#ifdef DEAL_II_WITH_CXX11
/**
* Move constructor. Construct a new sparse matrix by transferring the
* internal data of the matrix @p m into a new object.
*
* Move construction allows an object to be returned from a function or
* packed into a tuple even when the class cannot be copy-constructed.
- *
- * @note this constructor is only available if deal.II is configured with
- * C++11 support.
*/
SparseMatrix (SparseMatrix<number> &&m);
-#endif
/**
* Constructor. Takes the given matrix sparsity structure to represent the
/**
* Move assignment operator. This operator replaces the present matrix with
* @p m by transferring the internal data of @p m.
- *
- * @note This operator is only available if deal.II is configured with C++11
- * support.
*/
SparseMatrix<number> &operator = (SparseMatrix<number> &&m);
#endif
-#ifdef DEAL_II_WITH_CXX11
template <typename number>
SparseMatrix<number>::SparseMatrix (SparseMatrix<number> &&m)
:
m.val = nullptr;
m.max_len = 0;
}
-#endif
-#ifdef DEAL_II_WITH_CXX11
template <typename number>
SparseMatrix<number> &
SparseMatrix<number>::operator = (SparseMatrix<number> &&m)
return *this;
}
-#endif
}
-#ifdef DEAL_II_WITH_CXX11
-
namespace internal
{
} /*namespace BlockLinearOperator*/
} /* namespace internal */
-#endif // DEAL_II_WITH_CXX11
}/* namespace TrilinosWrappers */
#include <deal.II/base/config.h>
-#if defined(DEAL_II_WITH_CXX11) && defined(DEAL_II_WITH_TRILINOS)
+#if defined(DEAL_II_WITH_TRILINOS)
#include <deal.II/lac/linear_operator.h>
#include <deal.II/lac/block_linear_operator.h>
DEAL_II_NAMESPACE_CLOSE
-#endif // DEAL_II_WITH_CXX11 && DEAL_II_WITH_TRILINOS
+#endif // DEAL_II_WITH_TRILINOS
#endif
*/
BlockVector (const BlockVector &v);
-#ifdef DEAL_II_WITH_CXX11
/**
* Move constructor. Creates a new vector by stealing the internal data
* of the vector @p v.
- *
- * @note This constructor is only available if deal.II is configured
- * with C++11 support.
*/
BlockVector (BlockVector &&v);
-#endif
/**
* Creates a block vector consisting of <tt>num_blocks</tt> components,
*/
BlockVector &operator= (const BlockVector &v);
-#ifdef DEAL_II_WITH_CXX11
/**
* Move the given vector. This operator replaces the present vector with
* @p v by efficiently swapping the internal data structures.
- *
- * @note This operator is only available if deal.II is configured with
- * C++11 support.
*/
BlockVector &operator= (BlockVector &&v);
-#endif
/**
* Copy operator for arguments of the localized Trilinos vector type.
-#ifdef DEAL_II_WITH_CXX11
inline
BlockVector::BlockVector (BlockVector &&v)
{
reinit (0);
swap(v);
}
-#endif
# include <deal.II/lac/trilinos_vector.h>
# include <deal.II/lac/trilinos_epetra_vector.h>
# include <deal.II/lac/vector_view.h>
+# include <deal.II/lac/vector_memory.h>
-#ifdef DEAL_II_WITH_CXX11
-#include <deal.II/lac/vector_memory.h>
-#include <type_traits>
-#endif // DEAL_II_WITH_CXX11
-
+# include <type_traits>
# include <vector>
# include <cmath>
# include <memory>
};
-#ifdef DEAL_II_WITH_CXX11
// forwards declarations
class SolverBase;
} /* namespace LinearOperator */
} /* namespace internal */
-#endif // DEAL_II_WITH_CXX11
// -------------------------- inline and template functions ----------------------
}
-#ifdef DEAL_II_WITH_CXX11
namespace internal
{
namespace LinearOperator
}
} // namespace LinearOperator
} // namespace internal
-#endif // DEAL_II_WITH_CXX11
#endif // DOXYGEN
*/
Vector (const Vector &v);
-#ifdef DEAL_II_WITH_CXX11
/**
* Move constructor. Creates a new vector by stealing the internal data
* of the vector @p v.
- *
- * @note This constructor is only available if deal.II is configured
- * with C++11 support.
*/
Vector (Vector &&v);
-#endif
/**
* Destructor.
*/
Vector &operator= (const Vector &v);
-#ifdef DEAL_II_WITH_CXX11
/**
* Move the given vector. This operator replaces the present vector with
* @p v by efficiently swapping the internal data structures.
- *
- * @note This operator is only available if deal.II is configured with
- * C++11 support.
*/
Vector &operator= (Vector &&v);
-#endif
/**
* Copy operator from a given localized vector (present on all
*/
Vector (const Vector<Number> &v);
-#ifdef DEAL_II_WITH_CXX11
/**
* Move constructor. Creates a new vector by stealing the internal data of
* the vector @p v.
- *
- * @note This constructor is only available if deal.II is configured with
- * C++11 support.
*/
Vector (Vector<Number> &&v);
-#endif
-
#ifndef DEAL_II_EXPLICIT_CONSTRUCTOR_BUG
/**
* Move the given vector. This operator replaces the present vector with
* the internal data of the vector @p v and resets @p v to the state it would
* have after being newly default-constructed.
- *
- * @note This operator is only available if deal.II is configured with C++11
- * support.
*/
Vector<Number> &operator= (Vector<Number> &&v);
#endif
-#ifdef DEAL_II_WITH_CXX11
template <typename Number>
Vector<Number>::Vector (Vector<Number> &&v)
:
v.max_vec_size = 0;
v.val = nullptr;
}
-#endif
-#ifdef DEAL_II_WITH_CXX11
BlockVector &
BlockVector::operator= (BlockVector &&v)
{
swap(v);
return *this;
}
-#endif
# include <deal.II/lac/dynamic_sparsity_pattern.h>
# include <deal.II/lac/sparsity_tools.h>
# include <deal.II/lac/la_parallel_vector.h>
-
-#ifdef DEAL_II_WITH_CXX11
# include <deal.II/lac/trilinos_precondition.h>
-#endif
DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
# include <Epetra_Export.h>
}
}
-#ifdef DEAL_II_WITH_CXX11
namespace TrilinosWrappers
{
} /* namespace internal */
} /* namespace TrilinosWrappers */
-#endif // DEAL_II_WITH_CXX11
// explicit instantiations
-#ifdef DEAL_II_WITH_CXX11
Vector::Vector (Vector &&v)
{
// initialize a minimal, valid object and swap
swap(v);
}
-#endif
-#ifdef DEAL_II_WITH_CXX11
Vector &Vector::operator= (Vector &&v)
{
swap(v);
return *this;
}
-#endif
#include "../tests.h"
-#ifdef DEAL_II_WITH_CXX11
-
#include <deal.II/base/logstream.h>
#include <deal.II/base/tensor.h>
#include <deal.II/grid/tria.h>
test<2>();
}
-
-#else
-int main(int argc, char *argv[])
-{
- Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
- initlog();
- deallog << "Ok" << std::endl;
-}
-#endif
#include "../tests.h"
-#ifdef DEAL_II_WITH_CXX11
-
#include <deal.II/base/logstream.h>
#include <deal.II/base/tensor.h>
#include <deal.II/grid/tria.h>
test<2>();
}
-
-#else
-int main(int argc, char *argv[])
-{
- Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
- initlog();
- deallog << "Ok" << std::endl;
-}
-#endif
#include "../tests.h"
-#ifdef DEAL_II_WITH_CXX11
#include <deal.II/base/logstream.h>
#include <deal.II/base/tensor.h>
#include <deal.II/grid/tria.h>
test<2>();
}
-
-#else
-int main(int argc, char *argv[])
-{
- Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
- mpi_initlog();
-
- deallog << "Ok" << std::endl;
-}
-
-
-#endif
#include "../tests.h"
-#ifdef DEAL_II_WITH_CXX11
#include <deal.II/base/logstream.h>
#include <deal.II/base/tensor.h>
#include <deal.II/grid/tria.h>
test<2>();
}
-
-#else
-int main(int argc, char *argv[])
-{
- Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
- mpi_initlog();
-
- deallog << "Ok" << std::endl;
-}
-
-
-#endif
#include <deal.II/base/tensor_accessors.h>
#include <deal.II/base/table_indices.h>
-#ifdef DEAL_II_WITH_CXX11
#include <array>
-#endif
int main()
{
// via std::array
// via std::array:
-#ifdef DEAL_II_WITH_CXX11
std::array<unsigned int, 5> temp {{2, 1, 0, 2, 1}};
deallog << TensorAccessors::extract<5>(foo, temp) << std::endl;
-#else
- deallog << 42. << std::endl;
-#endif
}
}
// test with plain unique_ptr, but also copy stuff. this only works
// with move constructors, so test only in C++11 mode
-#ifdef DEAL_II_WITH_CXX11
{
AssertThrow (counter == 0, ExcInternalError());
{
}
AssertThrow (counter == 0, ExcInternalError());
}
-#endif
deallog << "OK" << std::endl;
}
projects / dealii.git / commitdiff