WorkStream::run(dof_handler.begin_active(),
dof_handler.end(),
- std_cxx11::bind(&Solver<dim>::local_assemble_matrix,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3),
- std_cxx11::bind(&Solver<dim>::copy_local_to_global,
- this,
- std_cxx11::_1,
- std_cxx11::ref(linear_system)),
+ std::bind(&Solver<dim>::local_assemble_matrix,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3),
+ std::bind(&Solver<dim>::copy_local_to_global,
+ this,
+ std::placeholders::_1,
+ std::ref(linear_system)),
AssemblyScratchData(*fe, *quadrature),
AssemblyCopyData());
linear_system.hanging_node_constraints.condense (linear_system.matrix);
- // The syntax above using <code>std_cxx11::bind</code> requires
+ // The syntax above using <code>std::bind</code> requires
// some explanation. There are multiple version of
// WorkStream::run that expect different arguments. In step-9,
// we used one version that took a pair of iterators, a pair of
// typical way to generate such function objects is using
// <code>std::bind</code> (or, if the compiler is too old, a
// replacement for it, which we generically call
- // <code>std_cxx11::bind</code>) which takes a pointer to a
+ // <code>std::bind</code>) which takes a pointer to a
// (member) function and then <i>binds</i> individual arguments
// to fixed values. For example, you can create a function that
// takes an iterator, a scratch object and a copy object by
// that can then be filled by WorkStream::run().
//
// There remains the question of what the
- // <code>std_cxx11::_1</code>, <code>std_cxx11::_2</code>, etc.,
+ // <code>std::placeholders::_1</code>, <code>std::placeholders::_2</code>, etc.,
// mean. (These arguments are called <i>placeholders</i>.) The
- // idea of using <code>std_cxx11::bind</code> in the first of
+ // idea of using <code>std::bind</code> in the first of
// the two cases above is that it produces an object that can be
// called with three arguments. But how are the three arguments
// the function object is being called with going to be
// games in other circumstances. Consider, for example, having a
// function <code>void f(double x, double y)</code>. Then,
// creating a variable <code>p</code> of type
- // <code>std_cxx11::function@<void f(double,double)@></code> and
- // initializing <code>p=std_cxx11::bind(&f, std_cxx11::_2,
- // std_cxx11::_1)</code> then calling <code>p(1,2)</code> will
+ // <code>std::function@<void f(double,double)@></code> and
+ // initializing <code>p=std::bind(&f, std::placeholders::_2,
+ // std::placeholders::_1)</code> then calling <code>p(1,2)</code> will
// result in calling <code>f(2,1)</code>.
//
// @note Once deal.II can rely on every compiler being able to
#include <deal.II/base/function.h>
#include <deal.II/base/logstream.h>
#include <deal.II/base/thread_management.h>
-#include <deal.II/base/std_cxx11/unique_ptr.h>
#include <deal.II/base/work_stream.h>
#include <deal.II/lac/vector.h>
#include <deal.II/lac/full_matrix.h>
#include <algorithm>
#include <numeric>
#include <sstream>
+#include <memory>
// The last step is as in all previous programs:
namespace Step14
WorkStream::run(dof_handler.begin_active(),
dof_handler.end(),
- std_cxx11::bind(&Solver<dim>::local_assemble_matrix,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3),
- std_cxx11::bind(&Solver<dim>::copy_local_to_global,
- this,
- std_cxx11::_1,
- std_cxx11::ref(linear_system)),
+ std::bind(&Solver<dim>::local_assemble_matrix,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3),
+ std::bind(&Solver<dim>::copy_local_to_global,
+ this,
+ std::placeholders::_1,
+ std::ref(linear_system)),
AssemblyScratchData(*fe, *quadrature),
AssemblyCopyData());
linear_system.hanging_node_constraints.condense (linear_system.matrix);
// in step-9:
void estimate_error (Vector<float> &error_indicators) const;
- void estimate_on_one_cell (const SynchronousIterators<std_cxx11::tuple<
+ void estimate_on_one_cell (const SynchronousIterators<std::tuple<
active_cell_iterator,Vector<float>::iterator> > &cell_and_error,
WeightedResidualScratchData &scratch_data,
WeightedResidualCopyData ©_data,
// interiors, on those faces that have no hanging nodes, and on those
// faces with hanging nodes, respectively:
void
- integrate_over_cell (const SynchronousIterators<std_cxx11::tuple<
+ integrate_over_cell (const SynchronousIterators<std::tuple<
active_cell_iterator,Vector<float>::iterator> > &cell_and_error,
const Vector<double> &primal_solution,
const Vector<double> &dual_weights,
.get_triangulation().n_active_cells());
typedef
- std
_cxx11::tuple<active_cell_iterator,Vector<float>::iterator>
+ std::tuple<active_cell_iterator,Vector<float>::iterator>
IteratorTuple;
SynchronousIterators<IteratorTuple>
WorkStream::run(cell_and_error_begin,
cell_and_error_end,
- std_cxx11::bind(&WeightedResidual<dim>::estimate_on_one_cell,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3,
- std_cxx11::ref(face_integrals)),
- std_cxx11::function<void (const WeightedResidualCopyData &)>(),
+ std::bind(&WeightedResidual<dim>::estimate_on_one_cell,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3,
+ std::ref(face_integrals)),
+ std::function<void (const WeightedResidualCopyData &)>(),
WeightedResidualScratchData (*DualSolver<dim>::fe,
*DualSolver<dim>::quadrature,
*DualSolver<dim>::face_quadrature,
template <int dim>
void
WeightedResidual<dim>::
- estimate_on_one_cell (const SynchronousIterators<std_cxx11::tuple<
+ estimate_on_one_cell (const SynchronousIterators<std::tuple<
active_cell_iterator,Vector<float>::iterator> > &cell_and_error,
WeightedResidualScratchData &scratch_data,
WeightedResidualCopyData ©_data,
// First task on each cell is to compute the cell residual
// contributions of this cell, and put them into the
// <code>error_indicators</code> variable:
- active_cell_iterator cell = std_cxx11::get<0>(*cell_and_error);
+ active_cell_iterator cell = std::get<0>(*cell_and_error);
integrate_over_cell (cell_and_error,
scratch_data.primal_solution,
// the cell terms:
template <int dim>
void WeightedResidual<dim>::
- integrate_over_cell (const SynchronousIterators<std_cxx11::tuple<
+ integrate_over_cell (const SynchronousIterators<std::tuple<
active_cell_iterator,Vector<float>::iterator> > &cell_and_error,
const Vector<double> &primal_solution,
const Vector<double> &dual_weights,
// error estimation formula: first get the right hand side and Laplacian
// of the numerical solution at the quadrature points for the cell
// residual,
- cell_data.fe_values.reinit (std_cxx11::get<0>(*cell_and_error));
+ cell_data.fe_values.reinit (std::get<0>(*cell_and_error));
cell_data.right_hand_side
->value_list (cell_data.fe_values.get_quadrature_points(),
cell_data.rhs_values);
sum += ((cell_data.rhs_values[p]+cell_data.cell_laplacians[p]) *
cell_data.dual_weights[p] *
cell_data.fe_values.JxW (p));
- *(std_cxx11::get<1>(*cell_and_error)) += sum;
+ *(std::get<1>(*cell_and_error)) += sum;
}
// side, domain, boundary values, etc. The pointer needed here defaults
// to the Null pointer, i.e. you will have to set it in actual instances
// of this object to make it useful.
- std_cxx11::unique_ptr<const Data::SetUpBase<dim> > data;
+ std::unique_ptr<const Data::SetUpBase<dim> > data;
// Since we allow to use different refinement criteria (global
// refinement, refinement by the Kelly error indicator, possibly with a
// Next, an object that describes the dual functional. It is only needed
// if the dual weighted residual refinement is chosen, and also defaults
// to a Null pointer.
- std_cxx11::unique_ptr<const DualFunctional::DualFunctionalBase<dim> >
+ std::unique_ptr<const DualFunctional::DualFunctionalBase<dim> >
dual_functional;
// Then a list of evaluation objects. Its default value is empty,
// pointer is zero, but you have to set it to some other value if you
// want to use the <code>weighted_kelly_indicator</code> refinement
// criterion.
- std_cxx11::unique_ptr<const Function<dim> > kelly_weight;
+ std::unique_ptr<const Function<dim> > kelly_weight;
// Finally, we have a variable that denotes the maximum number of
// degrees of freedom we allow for the (primal) discretization. If it is
// Next, select one of the classes implementing different refinement
// criteria.
- std_cxx11::unique_ptr<LaplaceSolver::Base<dim> > solver;
+ std::unique_ptr<LaplaceSolver::Base<dim> > solver;
switch (descriptor.refinement_criterion)
{
case ProblemDescription::dual_weighted_error_estimator:
// in how many places a preconditioner object is still referenced, it can
// never create a memory leak, and can never produce a dangling pointer to
// an already destroyed object:
- std_cxx11::shared_ptr<typename InnerPreconditioner<dim>::type> A_preconditioner;
+ std::shared_ptr<typename InnerPreconditioner<dim>::type> A_preconditioner;
};
// @sect3{Boundary values and right hand side}
std::cout << " Computing preconditioner..." << std::endl << std::flush;
A_preconditioner
- = std_cxx11::shared_ptr<typename InnerPreconditioner<dim>::type>(new typename InnerPreconditioner<dim>::type());
+ = std::shared_ptr<typename InnerPreconditioner<dim>::type>(new typename InnerPreconditioner<dim>::type());
A_preconditioner->initialize (system_matrix.block(0,0),
typename InnerPreconditioner<dim>::type::AdditionalData());
hp::QCollection<dim-1> face_quadrature_collection;
hp::QCollection<dim> fourier_q_collection;
- std_cxx11::shared_ptr<FESeries::Fourier<dim> > fourier;
+ std::shared_ptr<FESeries::Fourier<dim> > fourier;
std::vector<double> ln_k;
Table<dim,std::complex<double> > fourier_coefficients;
fourier_q_collection.push_back(quadrature);
// Now we are ready to set-up the FESeries::Fourier object
- fourier = std_cxx11::make_shared<FESeries::Fourier<dim> >(N,
- fe_collection,
- fourier_q_collection);
+ fourier = std::make_shared<FESeries::Fourier<dim> >(N,
+ fe_collection,
+ fourier_q_collection);
// We need to resize the matrix of fourier coefficients according to the
// number of modes N.
// k}|$ and thereby need to use VectorTools::Linfty_norm:
std::pair<std::vector<unsigned int>, std::vector<double> > res =
FESeries::process_coefficients<dim>(fourier_coefficients,
- std_cxx11::bind(&LaplaceProblem<dim>::predicate,
- this,
- std_cxx11::_1),
+ std::bind(&LaplaceProblem<dim>::predicate,
+ this,
+ std::placeholders::_1),
VectorTools::Linfty_norm);
Assert (res.first.size() == res.second.size(),
double old_time_step;
unsigned int timestep_number;
- std_cxx11::shared_ptr<TrilinosWrappers::PreconditionAMG> Amg_preconditioner;
- std_cxx11::shared_ptr<TrilinosWrappers::PreconditionIC> Mp_preconditioner;
+ std::shared_ptr<TrilinosWrappers::PreconditionAMG> Amg_preconditioner;
+ std::shared_ptr<TrilinosWrappers::PreconditionIC> Mp_preconditioner;
bool rebuild_stokes_matrix;
bool rebuild_temperature_matrices;
assemble_stokes_preconditioner ();
- Amg_preconditioner = std_cxx11::shared_ptr<TrilinosWrappers::PreconditionAMG>
+ Amg_preconditioner = std::shared_ptr<TrilinosWrappers::PreconditionAMG>
(new TrilinosWrappers::PreconditionAMG());
std::vector<std::vector<bool> > constant_modes;
// (IC) factorization preconditioner, which is designed for symmetric
// matrices. We could have also chosen an SSOR preconditioner with
// relaxation factor around 1.2, but IC is cheaper for our example. We
- // wrap the preconditioners into a <code>std_cxx11::shared_ptr</code>
+ // wrap the preconditioners into a <code>std::shared_ptr</code>
// pointer, which makes it easier to recreate the preconditioner next time
// around since we do not have to care about destroying the previously
// used object.
Amg_preconditioner->initialize(stokes_preconditioner_matrix.block(0,0),
amg_data);
- Mp_preconditioner = std_cxx11::shared_ptr<TrilinosWrappers::PreconditionIC>
+ Mp_preconditioner = std::shared_ptr<TrilinosWrappers::PreconditionIC>
(new TrilinosWrappers::PreconditionIC());
Mp_preconditioner->initialize(stokes_preconditioner_matrix.block(1,1));
double old_time_step;
unsigned int timestep_number;
- std_cxx11::shared_ptr<TrilinosWrappers::PreconditionAMG> Amg_preconditioner;
- std_cxx11::shared_ptr<TrilinosWrappers::PreconditionJacobi> Mp_preconditioner;
- std_cxx11::shared_ptr<TrilinosWrappers::PreconditionJacobi> T_preconditioner;
+ std::shared_ptr<TrilinosWrappers::PreconditionAMG> Amg_preconditioner;
+ std::shared_ptr<TrilinosWrappers::PreconditionJacobi> Mp_preconditioner;
+ std::shared_ptr<TrilinosWrappers::PreconditionJacobi> T_preconditioner;
bool rebuild_stokes_matrix;
bool rebuild_stokes_preconditioner;
// specific signatures: three arguments in the first and one
// argument in the latter case (see the documentation of the
// WorkStream::run function for the meaning of these arguments).
- // Note how we use the construct <code>std_cxx11::bind</code> to
+ // Note how we use the construct <code>std::bind</code> to
// create a function object that satisfies this requirement. It uses
- // placeholders <code>std_cxx11::_1, std_cxx11::_2,
- // std_cxx11::_3</code> for the local assembly function that specify
+ // placeholders <code>std::placeholders::_1, std::placeholders::_2,
+ // std::placeholders::_3</code> for the local assembly function that specify
// cell, scratch data, and copy data, as well as the placeholder
- // <code>std_cxx11::_1</code> for the copy function that expects the
+ // <code>std::placeholders::_1</code> for the copy function that expects the
// data to be written into the global matrix (for placeholder
// arguments, also see the discussion in step-13's
// <code>assemble_linear_system()</code> function). On the other
stokes_dof_handler.begin_active()),
CellFilter (IteratorFilters::LocallyOwnedCell(),
stokes_dof_handler.end()),
- std_cxx11::bind (&BoussinesqFlowProblem<dim>::
- local_assemble_stokes_preconditioner,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3),
- std_cxx11::bind (&BoussinesqFlowProblem<dim>::
- copy_local_to_global_stokes_preconditioner,
- this,
- std_cxx11::_1),
+ std::bind (&BoussinesqFlowProblem<dim>::
+ local_assemble_stokes_preconditioner,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3),
+ std::bind (&BoussinesqFlowProblem<dim>::
+ copy_local_to_global_stokes_preconditioner,
+ this,
+ std::placeholders::_1),
Assembly::Scratch::
StokesPreconditioner<dim> (stokes_fe, quadrature_formula,
mapping,
stokes_dof_handler.begin_active()),
CellFilter (IteratorFilters::LocallyOwnedCell(),
stokes_dof_handler.end()),
- std_cxx11::bind (&BoussinesqFlowProblem<dim>::
- local_assemble_stokes_system,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3),
- std_cxx11::bind (&BoussinesqFlowProblem<dim>::
- copy_local_to_global_stokes_system,
- this,
- std_cxx11::_1),
+ std::bind (&BoussinesqFlowProblem<dim>::
+ local_assemble_stokes_system,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3),
+ std::bind (&BoussinesqFlowProblem<dim>::
+ copy_local_to_global_stokes_system,
+ this,
+ std::placeholders::_1),
Assembly::Scratch::
StokesSystem<dim> (stokes_fe, mapping, quadrature_formula,
(update_values |
temperature_dof_handler.begin_active()),
CellFilter (IteratorFilters::LocallyOwnedCell(),
temperature_dof_handler.end()),
- std_cxx11::bind (&BoussinesqFlowProblem<dim>::
- local_assemble_temperature_matrix,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3),
- std_cxx11::bind (&BoussinesqFlowProblem<dim>::
- copy_local_to_global_temperature_matrix,
- this,
- std_cxx11::_1),
+ std::bind (&BoussinesqFlowProblem<dim>::
+ local_assemble_temperature_matrix,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3),
+ std::bind (&BoussinesqFlowProblem<dim>::
+ copy_local_to_global_temperature_matrix,
+ this,
+ std::placeholders::_1),
Assembly::Scratch::
TemperatureMatrix<dim> (temperature_fe, mapping, quadrature_formula),
Assembly::CopyData::
temperature_dof_handler.begin_active()),
CellFilter (IteratorFilters::LocallyOwnedCell(),
temperature_dof_handler.end()),
- std_cxx11::bind (&BoussinesqFlowProblem<dim>::
- local_assemble_temperature_rhs,
- this,
- global_T_range,
- maximal_velocity,
- global_entropy_variation,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3),
- std_cxx11::bind (&BoussinesqFlowProblem<dim>::
- copy_local_to_global_temperature_rhs,
- this,
- std_cxx11::_1),
+ std::bind (&BoussinesqFlowProblem<dim>::
+ local_assemble_temperature_rhs,
+ this,
+ global_T_range,
+ maximal_velocity,
+ global_entropy_variation,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3),
+ std::bind (&BoussinesqFlowProblem<dim>::
+ copy_local_to_global_temperature_rhs,
+ this,
+ std::placeholders::_1),
Assembly::Scratch::
TemperatureRHS<dim> (temperature_fe, stokes_fe, mapping,
quadrature_formula),
#include <deal.II/base/function_parser.h>
#include <deal.II/base/utilities.h>
#include <deal.II/base/conditional_ostream.h>
-#include <deal.II/base/std_cxx11/array.h>
#include <deal.II/lac/vector.h>
#include <deal.II/lac/dynamic_sparsity_pattern.h>
#include <fstream>
#include <vector>
#include <memory>
+#include <array>
// To end this section, introduce everything in the dealii library into the
// namespace into which the contents of this program will go:
template <typename InputVector>
static
void compute_flux_matrix (const InputVector &W,
- std_cxx11::array <std_cxx11::array
+ std::array <std::array
<typename InputVector::value_type, dim>,
EulerEquations<dim>::n_components > &flux)
{
const InputVector &Wplus,
const InputVector &Wminus,
const double alpha,
- std_cxx11::array
+ std::array
<typename InputVector::value_type, n_components>
&normal_flux)
{
- std_cxx11::array
- <std_cxx11::array <typename InputVector::value_type, dim>,
+ std::array
+ <std::array <typename InputVector::value_type, dim>,
EulerEquations<dim>::n_components > iflux, oflux;
compute_flux_matrix (Wplus, iflux);
template <typename InputVector>
static
void compute_forcing_vector (const InputVector &W,
- std_cxx11::array
+ std::array
<typename InputVector::value_type, n_components>
&forcing)
{
// later easily be computed from it:
std::vector <
- std_cxx11::array <std_cxx11::array <Sacado::Fad::DFad<double>, dim>, EulerEquations<dim>::n_components >
+ std::array <std::array <Sacado::Fad::DFad<double>, dim>, EulerEquations<dim>::n_components >
> flux(n_q_points);
std::vector <
- std_cxx11::array <std_cxx11::array <double, dim>, EulerEquations<dim>::n_components >
+ std::array <std::array <double, dim>, EulerEquations<dim>::n_components >
> flux_old(n_q_points);
- std::vector < std_cxx11::array< Sacado::Fad::DFad<double>, EulerEquations<dim>::n_components> > forcing(n_q_points);
+ std::vector < std::array< Sacado::Fad::DFad<double>, EulerEquations<dim>::n_components> > forcing(n_q_points);
- std::vector < std_cxx11::array< double, EulerEquations<dim>::n_components> > forcing_old(n_q_points);
+ std::vector < std::array< double, EulerEquations<dim>::n_components> > forcing_old(n_q_points);
for (unsigned int q=0; q<n_q_points; ++q)
{
// that does so, we also need to determine the Lax-Friedrich's stability
// parameter:
- std::vector< std_cxx11::array < Sacado::Fad::DFad<double>, EulerEquations<dim>::n_components> > normal_fluxes(n_q_points);
- std::vector< std_cxx11::array < double, EulerEquations<dim>::n_components> > normal_fluxes_old(n_q_points);
+ std::vector< std::array < Sacado::Fad::DFad<double>, EulerEquations<dim>::n_components> > normal_fluxes(n_q_points);
+ std::vector< std::array < double, EulerEquations<dim>::n_components> > normal_fluxes_old(n_q_points);
double alpha;
Functions::ParsedFunction<dim> exact_solution;
unsigned int singular_quadrature_order;
- std_cxx11::shared_ptr<Quadrature<dim-1> > quadrature;
+ std::shared_ptr<Quadrature<dim-1> > quadrature;
SolverControl solver_control;
prm.enter_subsection("Quadrature rules");
{
quadrature =
- std_cxx11::shared_ptr<Quadrature<dim-1> >
+ std::shared_ptr<Quadrature<dim-1> >
(new QuadratureSelector<dim-1> (prm.get("Quadrature type"),
prm.get_integer("Quadrature order")));
singular_quadrature_order = prm.get_integer("Singular quadrature order");
// the iterators stored internally is moved up one step as well, thereby
// always staying in sync. As it so happens, there is a deal.II class that
// facilitates this sort of thing.
- typedef std_cxx11::tuple< typename DoFHandler<dim>::active_cell_iterator,
+ typedef std::tuple< typename DoFHandler<dim>::active_cell_iterator,
typename DoFHandler<dim>::active_cell_iterator
> IteratorTuple;
InitGradScratchData &scratch,
InitGradPerTaskData &data)
{
- scratch.fe_val_vel.reinit (std_cxx11::get<0> (*SI));
- scratch.fe_val_pres.reinit (std_cxx11::get<1> (*SI));
+ scratch.fe_val_vel.reinit (std::get<0> (*SI));
+ scratch.fe_val_pres.reinit (std::get<1> (*SI));
- std_cxx11::get<0> (*SI)->get_dof_indices (data.vel_local_dof_indices);
- std_cxx11::get<1> (*SI)->get_dof_indices (data.pres_local_dof_indices);
+ std::get<0> (*SI)->get_dof_indices (data.vel_local_dof_indices);
+ std::get<1> (*SI)->get_dof_indices (data.pres_local_dof_indices);
data.local_grad = 0.;
for (unsigned int q=0; q<scratch.nqp; ++q)
MatrixFree<dim,double>::AdditionalData::none;
additional_data.mapping_update_flags = (update_gradients | update_JxW_values |
update_quadrature_points);
- std_cxx11::shared_ptr<MatrixFree<dim,double> >
+ std::shared_ptr<MatrixFree<dim,double> >
system_mf_storage(new MatrixFree<dim,double>());
system_mf_storage->reinit (dof_handler, constraints, QGauss<1>(fe.degree+1),
additional_data);
additional_data.mapping_update_flags = (update_gradients | update_JxW_values |
update_quadrature_points);
additional_data.level_mg_handler = level;
- std_cxx11::shared_ptr<MatrixFree<dim,float> >
+ std::shared_ptr<MatrixFree<dim,float> >
mg_mf_storage_level(new MatrixFree<dim,float>());
mg_mf_storage_level->reinit(dof_handler, level_constraints,
QGauss<1>(fe.degree+1), additional_data);
// one shot at setting it; the same is true for the mesh refinement
// criterion):
const std::string base_mesh;
- const std_cxx11::shared_ptr<const Function<dim> > obstacle;
+ const std::shared_ptr<const Function<dim> > obstacle;
struct RefinementStrategy
{
#include <deal.II/base/utilities.h>
#include <deal.II/base/function.h>
#include <deal.II/base/tensor_function.h>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
#include <deal.II/base/index_set.h>
#include <deal.II/lac/full_matrix.h>
#include <iostream>
#include <fstream>
#include <sstream>
+#include <memory>
// At the end of this top-matter, we open a namespace for the current project
const double porosity;
const double AOS_threshold;
- std_cxx11::shared_ptr<TrilinosWrappers::PreconditionIC> Amg_preconditioner;
- std_cxx11::shared_ptr<TrilinosWrappers::PreconditionIC> Mp_preconditioner;
+ std::shared_ptr<TrilinosWrappers::PreconditionIC> Amg_preconditioner;
+ std::shared_ptr<TrilinosWrappers::PreconditionIC> Mp_preconditioner;
bool rebuild_saturation_matrix;
{
assemble_darcy_preconditioner ();
- Amg_preconditioner = std_cxx11::shared_ptr<TrilinosWrappers::PreconditionIC>
+ Amg_preconditioner = std::shared_ptr<TrilinosWrappers::PreconditionIC>
(new TrilinosWrappers::PreconditionIC());
Amg_preconditioner->initialize(darcy_preconditioner_matrix.block(0,0));
- Mp_preconditioner = std_cxx11::shared_ptr<TrilinosWrappers::PreconditionIC>
+ Mp_preconditioner = std::shared_ptr<TrilinosWrappers::PreconditionIC>
(new TrilinosWrappers::PreconditionIC());
Mp_preconditioner->initialize(darcy_preconditioner_matrix.block(1,1));
// materials are used in different regions of the domain, as well as the
// inverse of the deformation gradient...
private:
- std_cxx11::shared_ptr< Material_Compressible_Neo_Hook_Three_Field<dim> > material;
+ std::shared_ptr< Material_Compressible_Neo_Hook_Three_Field<dim> > material;
Tensor<2, dim> F_inv;
// non-constant.
WorkStream::run(dof_handler_ref.begin_active(),
dof_handler_ref.end(),
- std_cxx11::bind(&Solid<dim>::assemble_system_tangent_one_cell,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3),
- std_cxx11::bind(&Solid<dim>::copy_local_to_global_K,
- this,
- std_cxx11::_1),
+ std::bind(&Solid<dim>::assemble_system_tangent_one_cell,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3),
+ std::bind(&Solid<dim>::copy_local_to_global_K,
+ this,
+ std::placeholders::_1),
scratch_data,
per_task_data);
WorkStream::run(dof_handler_ref.begin_active(),
dof_handler_ref.end(),
- std_cxx11::bind(&Solid<dim>::assemble_system_rhs_one_cell,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3),
- std_cxx11::bind(&Solid<dim>::copy_local_to_global_rhs,
- this,
- std_cxx11::_1),
+ std::bind(&Solid<dim>::assemble_system_rhs_one_cell,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3),
+ std::bind(&Solid<dim>::copy_local_to_global_rhs,
+ this,
+ std::placeholders::_1),
scratch_data,
per_task_data);
WorkStream::run(dof_handler_u_post.begin_active(),
dof_handler_u_post.end(),
- std_cxx11::bind (&HDG<dim>::postprocess_one_cell,
- std_cxx11::ref(*this),
- std_cxx11::_1, std_cxx11::_2, std_cxx11::_3),
- std_cxx11::function<void(const unsigned int &)>(),
+ std::bind (&HDG<dim>::postprocess_one_cell,
+ std::ref(*this),
+ std::placeholders::_1, std::placeholders::_2, std::placeholders::_3),
+ std::function<void(const unsigned int &)>(),
scratch,
0U);
}
for (unsigned int i=0; i<n_time_steps; ++i)
{
time = explicit_runge_kutta.evolve_one_time_step(
- std_cxx11::bind(&Diffusion::evaluate_diffusion,
- this,
- std_cxx11::_1,
- std_cxx11::_2),
+ std::bind(&Diffusion::evaluate_diffusion,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2),
time,time_step,solution);
if ((i+1)%10==0)
for (unsigned int i=0; i<n_time_steps; ++i)
{
time = implicit_runge_kutta.evolve_one_time_step(
- std_cxx11::bind(&Diffusion::evaluate_diffusion,
- this,
- std_cxx11::_1,
- std_cxx11::_2),
- std_cxx11::bind(&Diffusion::id_minus_tau_J_inverse,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3),
+ std::bind(&Diffusion::evaluate_diffusion,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2),
+ std::bind(&Diffusion::id_minus_tau_J_inverse,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3),
time,time_step,solution);
if ((i+1)%10==0)
time_step = final_time-time;
time = embedded_explicit_runge_kutta.evolve_one_time_step(
- std_cxx11::bind(&Diffusion::evaluate_diffusion,this,std_cxx11::_1,std_cxx11::_2),
+ std::bind(&Diffusion::evaluate_diffusion,this,std::placeholders::_1,std::placeholders::_2),
time,time_step,solution);
if ((n_steps+1)%10==0)
private:
const Functions::InterpolatedUniformGridData<2> topography_data;
- static std_cxx11::array<std::pair<double,double>,2> get_endpoints ();
- static std_cxx11::array<unsigned int,2> n_intervals ();
+ static std::array<std::pair<double,double>,2> get_endpoints ();
+ static std::array<unsigned int,2> n_intervals ();
static std::vector<double> get_data ();
};
}
- std_cxx11::array<std::pair<double,double>,2>
+ std::array<std::pair<double,double>,2>
AfricaTopography::get_endpoints ()
{
- std_cxx11::array<std::pair<double,double>,2> endpoints;
+ std::array<std::pair<double,double>,2> endpoints;
endpoints[0] = std::make_pair (-6.983333, 11.966667);
endpoints[1] = std::make_pair (25, 35.95);
return endpoints;
}
- std_cxx11::array<unsigned int,2>
+ std::array<unsigned int,2>
AfricaTopography::n_intervals ()
{
- std_cxx11::array<unsigned int,2> endpoints;
+ std::array<unsigned int,2> endpoints;
endpoints[0] = 379;
endpoints[1] = 219;
return endpoints;
corner_points[0], corner_points[1],
true);
- GridTools::transform (std_cxx11::bind(&AfricaGeometry::push_forward,
- std_cxx11::cref(geometry),
- std_cxx11::_1),
+ GridTools::transform (std::bind(&AfricaGeometry::push_forward,
+ std::cref(geometry),
+ std::placeholders::_1),
triangulation);
}
template <int dim>
static
- void estimate_cell (const SynchronousIterators<std_cxx11::tuple<typename DoFHandler<dim>::active_cell_iterator,
+ void estimate_cell (const SynchronousIterators<std::tuple<typename DoFHandler<dim>::active_cell_iterator,
Vector<float>::iterator> > &cell,
EstimateScratchData<dim> &scratch_data,
const EstimateCopyData ©_data);
ExcInvalidVectorLength (error_per_cell.size(),
dof_handler.get_triangulation().n_active_cells()));
- typedef std_cxx11::tuple<typename DoFHandler<dim>::active_cell_iterator,Vector<float>::iterator>
+ typedef std::tuple<typename DoFHandler<dim>::active_cell_iterator,Vector<float>::iterator>
IteratorTuple;
SynchronousIterators<IteratorTuple>
WorkStream::run (begin_sync_it,
end_sync_it,
&GradientEstimation::template estimate_cell<dim>,
- std_cxx11::function<void (const EstimateCopyData &)> (),
+ std::function<void (const EstimateCopyData &)> (),
EstimateScratchData<dim> (dof_handler.get_fe(),
solution),
EstimateCopyData ());
// passing the following as the third argument when calling WorkStream::run
// above:
// @code
- // std_cxx11::function<void (const SynchronousIterators<IteratorTuple> &,
- // EstimateScratchData<dim> &,
- // EstimateCopyData &)>
- // (std_cxx11::bind (&GradientEstimation::template estimate_cell<dim>,
- // std_cxx11::_1,
- // std_cxx11::_2))
+ // std::function<void (const SynchronousIterators<IteratorTuple> &,
+ // EstimateScratchData<dim> &,
+ // EstimateCopyData &)>
+ // (std::bind (&GradientEstimation::template estimate_cell<dim>,
+ // std::placeholders::_1,
+ // std::placeholders::_2))
// @endcode
// This creates a function object taking three arguments, but when it calls
// the underlying function object, it simply only uses the first and second
// Now for the details:
template <int dim>
void
- GradientEstimation::estimate_cell (const SynchronousIterators<std_cxx11::tuple<typename DoFHandler<dim>::active_cell_iterator,
+ GradientEstimation::estimate_cell (const SynchronousIterators<std::tuple<typename DoFHandler<dim>::active_cell_iterator,
Vector<float>::iterator> > &cell,
EstimateScratchData<dim> &scratch_data,
const EstimateCopyData &)
active_neighbors.reserve (GeometryInfo<dim>::faces_per_cell *
GeometryInfo<dim>::max_children_per_face);
- typename DoFHandler<dim>::active_cell_iterator cell_it(std_cxx11::get<0>(*cell));
+ typename DoFHandler<dim>::active_cell_iterator cell_it(std::get<0>(*cell));
// First initialize the <code>FEValues</code> object, as well as the
// <code>Y</code> tensor:
// neighbors, of course.
active_neighbors.clear ();
for (unsigned int face_no=0; face_no<GeometryInfo<dim>::faces_per_cell; ++face_no)
- if (! std_cxx11::get<0>(*cell)->at_boundary(face_no))
+ if (! std::get<0>(*cell)->at_boundary(face_no))
{
// First define an abbreviation for the iterator to the face and
// the neighbor
const typename DoFHandler<dim>::face_iterator
- face = std_cxx11::get<0>(*cell)->face(face_no);
+ face = std::get<0>(*cell)->face(face_no);
const typename DoFHandler<dim>::cell_iterator
- neighbor = std_cxx11::get<0>(*cell)->neighbor(face_no);
+ neighbor = std::get<0>(*cell)->neighbor(face_no);
// Then check whether the neighbor is active. If it is, then it
// is on the same level or one level coarser (if we are not in
// as an internal error. We therefore use a predefined
// exception class to throw here.
Assert (neighbor_child->neighbor(face_no==0 ? 1 : 0)
- ==std_cxx11::get<0>(*cell),ExcInternalError());
+ ==std::get<0>(*cell),ExcInternalError());
// If the check succeeded, we push the active neighbor
// we just found to the stack we keep:
// `behind' the subfaces of the current face
for (unsigned int subface_no=0; subface_no<face->n_children(); ++subface_no)
active_neighbors.push_back (
- std_cxx11::get<0>(*cell)->neighbor_child_on_subface(face_no,subface_no));
+ std::get<0>(*cell)->neighbor_child_on_subface(face_no,subface_no));
}
}
// at the second element of the pair of iterators, which requires
// slightly awkward syntax but is not otherwise particularly
// difficult:
- *(std_cxx11::get<1>(*cell)) = (std::pow(std_cxx11::get<0>(*cell)->diameter(),
- 1+1.0*dim/2) *
- std::sqrt(gradient.norm_square()));
+ *(std::get<1>(*cell)) = (std::pow(std::get<0>(*cell)->diameter(),
+ 1+1.0*dim/2) *
+ std::sqrt(gradient.norm_square()));
}
}
#define dealii__aligned_vector_h
#include <deal.II/base/config.h>
-#include <deal.II/base/std_cxx11/type_traits.h>
#include <deal.II/base/exceptions.h>
#include <deal.II/base/memory_consumption.h>
#include <deal.II/base/utilities.h>
#include <boost/serialization/split_member.hpp>
#include <cstring>
+#include <type_traits>
// (void*) to silence compiler warning for virtual classes (they will
// never arrive here because they are non-trivial).
- if (std_cxx11::is_trivial<T>::value == true)
+ if (std::is_trivial<T>::value == true)
std::memcpy ((void *)(destination_+begin), (void *)(source_+begin),
(end-begin)*sizeof(T));
else if (copy_source_ == false)
// do not use memcmp for long double because on some systems it does not
// completely fill its memory and may lead to false positives in
// e.g. valgrind
- if (std_cxx11::is_trivial<T>::value == true &&
+ if (std::is_trivial<T>::value == true &&
types_are_equal<T,long double>::value == false)
{
const unsigned char zero [sizeof(T)] = {};
// element to (void*) to silence compiler warning for virtual
// classes (they will never arrive here because they are
// non-trivial).
- if (std_cxx11::is_trivial<T>::value == true && trivial_element)
+ if (std::is_trivial<T>::value == true && trivial_element)
std::memset ((void *)(destination_+begin), 0, (end-begin)*sizeof(T));
else
copy_construct_or_assign(begin, end,
AlignedVector<T>::resize_fast (const size_type size_in)
{
const size_type old_size = size();
- if (std_cxx11::is_trivial<T>::value == false && size_in < old_size)
+ if (std::is_trivial<T>::value == false && size_in < old_size)
{
// call destructor on fields that are released. doing it backward
// releases the elements in reverse order as compared to how they were
// need to still set the values in case the class is non-trivial because
// virtual classes etc. need to run their (default) constructor
- if (std_cxx11::is_trivial<T>::value == false && size_in > old_size)
+ if (std::is_trivial<T>::value == false && size_in > old_size)
dealii::internal::AlignedVectorSet<T,true> (size_in-old_size, T(), _data+old_size);
}
const T &init)
{
const size_type old_size = size();
- if (std_cxx11::is_trivial<T>::value == false && size_in < old_size)
+ if (std::is_trivial<T>::value == false && size_in < old_size)
{
// call destructor on fields that are released. doing it backward
// releases the elements in reverse order as compared to how they were
{
if (_data != 0)
{
- if (std_cxx11::is_trivial<T>::value == false)
+ if (std::is_trivial<T>::value == false)
while (_end_data != _data)
(--_end_data)->~T();
Assert (_end_data <= _end_allocated, ExcInternalError());
if (_end_data == _end_allocated)
reserve (std::max(2*capacity(),static_cast<size_type>(16)));
- if (std_cxx11::is_trivial<T>::value == false)
+ if (std::is_trivial<T>::value == false)
new (_end_data++) T(in_data);
else
*_end_data++ = in_data;
reserve (old_size + (end-begin));
for ( ; begin != end; ++begin, ++_end_data)
{
- if (std_cxx11::is_trivial<T>::value == false)
+ if (std::is_trivial<T>::value == false)
new (_end_data) T;
*_end_data = *begin;
}
#include <deal.II/base/point.h>
#include <deal.II/base/table.h>
#include <deal.II/base/geometry_info.h>
-#include <deal.II/base/std_cxx11/tuple.h>
#include <vector>
#include <string>
#include <limits>
#include <typeinfo>
+#include <tuple>
#include <deal.II/base/mpi.h>
template <int dim, int spacedim>
void write_dx (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const DXFlags &flags,
std::ostream &out);
template <int spacedim>
void write_eps (const std::vector<Patch<2,spacedim> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const EpsFlags &flags,
std::ostream &out);
template <int dim, int spacedim>
void write_eps (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const EpsFlags &flags,
std::ostream &out);
template <int dim, int spacedim>
void write_gmv (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const GmvFlags &flags,
std::ostream &out);
template <int dim, int spacedim>
void write_gnuplot (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const GnuplotFlags &flags,
std::ostream &out);
template <int dim, int spacedim>
void write_povray (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const PovrayFlags &flags,
std::ostream &out);
template <int dim, int spacedim>
void write_tecplot (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const TecplotFlags &flags,
std::ostream &out);
void write_tecplot_binary (
const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const TecplotFlags &flags,
std::ostream &out);
template <int dim, int spacedim>
void write_ucd (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const UcdFlags &flags,
std::ostream &out);
template <int dim, int spacedim>
void write_vtk (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const VtkFlags &flags,
std::ostream &out);
template <int dim, int spacedim>
void write_vtu (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const VtkFlags &flags,
std::ostream &out);
template <int dim, int spacedim>
void write_vtu_main (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const VtkFlags &flags,
std::ostream &out);
write_pvtu_record (std::ostream &out,
const std::vector<std::string> &piece_names,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges);
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges);
/**
* In ParaView it is possible to visualize time-dependent data tagged with
template <int spacedim>
void write_svg (const std::vector<Patch<2,spacedim> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const SvgFlags &flags,
std::ostream &out);
void write_deal_II_intermediate (
const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const Deal_II_IntermediateFlags &flags,
std::ostream &out);
template <int dim, int spacedim>
void write_filtered_data (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
DataOutFilter &filtered_data);
/**
* fields.
*/
virtual
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> >
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> >
get_vector_data_ranges () const;
/**
* fields.
*/
virtual
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> >
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> >
get_vector_data_ranges () const;
private:
* Information about whether certain components of the output field are to
* be considered vectors.
*/
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> >
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> >
vector_data_ranges;
};
#include <deal.II/base/tensor.h>
#include <deal.II/base/symmetric_tensor.h>
#include <deal.II/base/point.h>
-#include <deal.II/base/std_cxx11/function.h>
+#include <functional>
#include <vector>
DEAL_II_NAMESPACE_OPEN
* or we could write it like so:
* @code
* ScalarFunctionFromFunctionObject<dim, Number>
- * my_distance_object (std_cxx11::bind (&Point<dim>::distance,
+ * my_distance_object (std::bind (&Point<dim>::distance,
* q,
- * std_cxx11::_1));
+ * std::placeholders::_1));
* @endcode
* The savings in work to write this are apparent.
*
* convert this into an object that matches the Function<dim, Number>
* interface.
*/
- ScalarFunctionFromFunctionObject (const std_cxx11::function<Number (const Point<dim> &)> &function_object);
+ ScalarFunctionFromFunctionObject (const std::function<Number (const Point<dim> &)> &function_object);
/**
* Return the value of the function at the given point. Returns the value
* The function object which we call when this class's value() or
* value_list() functions are called.
*/
- const std_cxx11::function<Number (const Point<dim> &)> function_object;
+ const std::function<Number (const Point<dim> &)> function_object;
};
* @param selected_component The single component that should be filled by
* the first argument.
*/
- VectorFunctionFromScalarFunctionObject (const std_cxx11::function<Number (const Point<dim> &)> &function_object,
+ VectorFunctionFromScalarFunctionObject (const std::function<Number (const Point<dim> &)> &function_object,
const unsigned int selected_component,
const unsigned int n_components);
* The function object which we call when this class's value() or
* value_list() functions are called.
*/
- const std_cxx11::function<Number (const Point<dim> &)> function_object;
+ const std::function<Number (const Point<dim> &)> function_object;
/**
* The vector component whose value is to be filled by the given scalar
template <int dim, typename Number>
ScalarFunctionFromFunctionObject<dim, Number>::
-ScalarFunctionFromFunctionObject (const std_cxx11::function<Number (const Point<dim> &)> &function_object)
+ScalarFunctionFromFunctionObject (const std::function<Number (const Point<dim> &)> &function_object)
:
Function<dim, Number>(1),
function_object (function_object)
template <int dim, typename Number>
VectorFunctionFromScalarFunctionObject<dim, Number>::
VectorFunctionFromScalarFunctionObject (
- const std_cxx11::function<Number (const Point<dim> &)> &function_object,
+ const std::function<Number (const Point<dim> &)> &function_object,
const unsigned int selected_component,
const unsigned int n_components)
:
#include <deal.II/base/point.h>
#include <deal.II/base/table.h>
-#include <deal.II/base/std_cxx11/array.h>
+#include <array>
DEAL_II_NAMESPACE_OPEN
* class has a number of conversion constructors that allow converting
* other data types into a table where you specify this argument.
*/
- InterpolatedTensorProductGridData (const std_cxx11::array<std::vector<double>,dim> &coordinate_values,
- const Table<dim,double> &data_values);
+ InterpolatedTensorProductGridData (const std::array<std::vector<double>,dim> &coordinate_values,
+ const Table<dim,double> &data_values);
/**
* Compute the value of the function set by bilinear interpolation of the
/**
* The set of coordinate values in each of the coordinate directions.
*/
- const std_cxx11::array<std::vector<double>,dim> coordinate_values;
+ const std::array<std::vector<double>,dim> coordinate_values;
/**
* The data that is to be interpolated.
* class has a number of conversion constructors that allow converting
* other data types into a table where you specify this argument.
*/
- InterpolatedUniformGridData (const std_cxx11::array<std::pair<double,double>,dim> &interval_endpoints,
- const std_cxx11::array<unsigned int,dim> &n_subintervals,
+ InterpolatedUniformGridData (const std::array<std::pair<double,double>,dim> &interval_endpoints,
+ const std::array<unsigned int,dim> &n_subintervals,
const Table<dim,double> &data_values);
/**
/**
* The set of interval endpoints in each of the coordinate directions.
*/
- const std_cxx11::array<std::pair<double,double>,dim> interval_endpoints;
+ const std::array<std::pair<double,double>,dim> interval_endpoints;
/**
* The number of subintervals in each of the coordinate directions.
*/
- const std_cxx11::array<unsigned int,dim> n_subintervals;
+ const std::array<unsigned int,dim> n_subintervals;
/**
* The data that is to be interpolated.
#include <deal.II/base/function.h>
#include <deal.II/base/point.h>
-#include <deal.II/base/std_cxx11/array.h>
+
+
+#include <array>
DEAL_II_NAMESPACE_OPEN
* Return the value at point @p sp. Here, @p sp is provided in spherical
* coordinates.
*/
- virtual double svalue(const std_cxx11::array<double, dim> &sp,
+ virtual double svalue(const std::array<double, dim> &sp,
const unsigned int component) const;
/**
* The returned object should contain derivatives in the following order:
* $\{ f_{,r},\, f_{,\theta},\, f_{,\phi}\}$.
*/
- virtual std_cxx11::array<double, dim> sgradient(const std_cxx11::array<double, dim> &sp,
- const unsigned int component) const;
+ virtual std::array<double, dim> sgradient(const std::array<double, dim> &sp,
+ const unsigned int component) const;
/**
* Return the Hessian in spherical coordinates.
* The returned object should contain derivatives in the following order:
* $\{ f_{,rr},\, f_{,\theta\theta},\, f_{,\phi\phi},\, f_{,r\theta},\, f_{,r\phi},\, f_{,\theta\phi}\}$.
*/
- virtual std_cxx11::array<double, 6> shessian (const std_cxx11::array<double, dim> &sp,
- const unsigned int component) const;
+ virtual std::array<double, 6> shessian (const std::array<double, dim> &sp,
+ const unsigned int component) const;
/**
* A vector from the origin to the center of spherical coordinate system.
#include <deal.II/base/config.h>
#include <deal.II/base/point.h>
-#include <deal.II/base/std_cxx11/array.h>
+
+
+#include <array>
DEAL_II_NAMESPACE_OPEN
* @f}
*/
template <int dim>
- std_cxx11::array<double,dim>
+ std::array<double,dim>
to_spherical(const Point<dim> &point);
/**
*/
template <std::size_t dim>
Point<dim>
- from_spherical(const std_cxx11::array<double,dim> &scoord);
+ from_spherical(const std::array<double,dim> &scoord);
}
}
#include <deal.II/base/config.h>
#include <deal.II/base/thread_management.h>
-#include <deal.II/base/std_cxx11/function.h>
#include <boost/unordered_map.hpp>
#include <boost/unordered_set.hpp>
+#include <functional>
#include <set>
#include <vector>
std::vector<std::vector<Iterator> >
create_partitioning(const Iterator &begin,
const typename identity<Iterator>::type &end,
- const std_cxx11::function<std::vector<types::global_dof_index> (const Iterator &)> &get_conflict_indices)
+ const std::function<std::vector<types::global_dof_index> (const Iterator &)> &get_conflict_indices)
{
// Number of iterators.
unsigned int n_iterators = 0;
template <typename Iterator>
void
make_dsatur_coloring(std::vector<Iterator> &partition,
- const std_cxx11::function<std::vector<types::global_dof_index> (const Iterator &)> &get_conflict_indices,
+ const std::function<std::vector<types::global_dof_index> (const Iterator &)> &get_conflict_indices,
std::vector<std::vector<Iterator> > &partition_coloring)
{
partition_coloring.clear ();
std::vector<std::vector<Iterator> >
make_graph_coloring(const Iterator &begin,
const typename identity<Iterator>::type &end,
- const std_cxx11::function<std::vector<types::global_dof_index> (const typename identity<Iterator>::type &)> &get_conflict_indices)
+ const std::function<std::vector<types::global_dof_index> (const typename identity<Iterator>::type &)> &get_conflict_indices)
{
Assert (begin != end, ExcMessage ("GraphColoring is not prepared to deal with empty ranges!"));
#include <deal.II/base/config.h>
#include <deal.II/base/exceptions.h>
#include <deal.II/base/smartpointer.h>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
#include <deal.II/base/thread_local_storage.h>
#include <string>
#include <map>
#include <cmath>
#include <sstream>
+#include <memory>
#ifdef DEAL_II_HAVE_SYS_TIMES_H
# include <sys/times.h>
* We use tbb's thread local storage facility to generate a stringstream for
* every thread that sends log messages.
*/
- Threads::ThreadLocalStorage<std_cxx11::shared_ptr<std::ostringstream> > outstreams;
+ Threads::ThreadLocalStorage<std::shared_ptr<std::ostringstream> > outstreams;
template <typename T> friend LogStream &operator << (LogStream &log, const T &t);
};
#include <deal.II/base/config.h>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
-#include <deal.II/base/std_cxx11/type_traits.h>
-#include <deal.II/base/std_cxx11/unique_ptr.h>
-#include <deal.II/base/std_cxx11/array.h>
#include <string>
#include <complex>
#include <vector>
#include <cstddef>
#include <cstring>
+#include <memory>
+#include <array>
+#include <type_traits>
DEAL_II_NAMESPACE_OPEN
*/
template <typename T>
inline
- typename std_cxx11::enable_if<std_cxx11::is_fundamental<T>::value, std::size_t>::type
+ typename std::enable_if<std::is_fundamental<T>::value, std::size_t>::type
memory_consumption (const T &t);
/**
*/
template <typename T>
inline
- typename std_cxx11::enable_if<!(std_cxx11::is_fundamental<T>::value || std_cxx11::is_pointer<T>::value), std::size_t>::type
+ typename std::enable_if<!(std::is_fundamental<T>::value || std::is_pointer<T>::value), std::size_t>::type
memory_consumption (const T &t);
/**
/**
* Determine the amount of memory in bytes consumed by a
- * <tt>std_cxx11::array</tt> of <tt>N</tt> elements of type <tt>T</tt> by
+ * <tt>std::array</tt> of <tt>N</tt> elements of type <tt>T</tt> by
* calling memory_consumption() for each entry.
*
* This function loops over all entries of the array and determines their
*/
template <typename T, std::size_t N>
inline
- std::size_t memory_consumption (const std_cxx11::array<T,N> &v);
+ std::size_t memory_consumption (const std::array<T,N> &v);
/**
* Estimate the amount of memory (in bytes) occupied by a C-style array.
*/
template <typename T>
inline
- std::size_t memory_consumption (const std_cxx11::shared_ptr<T> &);
+ std::size_t memory_consumption (const std::shared_ptr<T> &);
/**
- * Return the amount of memory used by a std_cxx11::unique_ptr object.
+ * Return the amount of memory used by a std::unique_ptr object.
*
* @note This returns the size of the pointer, not of the object pointed to.
*/
template <typename T>
inline
- std::size_t memory_consumption (const std_cxx11::unique_ptr<T> &);
+ std::size_t memory_consumption (const std::unique_ptr<T> &);
}
{
template <typename T>
inline
- typename std_cxx11::enable_if<std_cxx11::is_fundamental<T>::value, std::size_t>::type
+ typename std::enable_if<std::is_fundamental<T>::value, std::size_t>::type
memory_consumption(const T &)
{
return sizeof(T);
std::size_t memory_consumption (const std::vector<T> &v)
{
// shortcut for types that do not allocate memory themselves
- if (std_cxx11::is_fundamental<T>::value || std_cxx11::is_pointer<T>::value)
+ if (std::is_fundamental<T>::value || std::is_pointer<T>::value)
{
return v.capacity()*sizeof(T) + sizeof(v);
}
template <typename T, std::size_t N>
- std::size_t memory_consumption (const std_cxx11::array<T,N> &v)
+ std::size_t memory_consumption (const std::array<T,N> &v)
{
// shortcut for types that do not allocate memory themselves
- if (std_cxx11::is_fundamental<T>::value || std_cxx11::is_pointer<T>::value)
+ if (std::is_fundamental<T>::value || std::is_pointer<T>::value)
{
return sizeof(v);
}
template <typename T>
inline
std::size_t
- memory_consumption (const std_cxx11::shared_ptr<T> &)
+ memory_consumption (const std::shared_ptr<T> &)
{
- return sizeof(std_cxx11::shared_ptr<T>);
+ return sizeof(std::shared_ptr<T>);
}
template <typename T>
inline
std::size_t
- memory_consumption (const std_cxx11::unique_ptr<T> &)
+ memory_consumption (const std::unique_ptr<T> &)
{
- return sizeof(std_cxx11::unique_ptr<T>);
+ return sizeof(std::unique_ptr<T>);
}
template <typename T>
inline
- typename std_cxx11::enable_if<!(std_cxx11::is_fundamental<T>::value || std_cxx11::is_pointer<T>::value), std::size_t>::type
+ typename std::enable_if<!(std::is_fundamental<T>::value || std::is_pointer<T>::value), std::size_t>::type
memory_consumption (const T &t)
{
return t.memory_consumption();
#include <deal.II/base/subscriptor.h>
#include <vector>
-
-#include <deal.II/base/std_cxx11/shared_ptr.h>
+#include <memory>
DEAL_II_NAMESPACE_OPEN
/**
* Array of the objects to be held.
*/
- std::vector<std_cxx11::shared_ptr<Object> > objects;
+ std::vector<std::shared_ptr<Object> > objects;
};
minlevel = new_minlevel;
for (unsigned int i=0; i<new_maxlevel-new_minlevel+1; ++i)
- objects.push_back(std_cxx11::shared_ptr<Object> (new Object));
+ objects.push_back(std::shared_ptr<Object> (new Object));
}
MGLevelObject<Object> &
MGLevelObject<Object>::operator = (const double d)
{
- typename std::vector<std_cxx11::shared_ptr<Object> >::iterator v;
+ typename std::vector<std::shared_ptr<Object> >::iterator v;
for (v = objects.begin(); v != objects.end(); ++v)
**v=d;
return *this;
void
MGLevelObject<Object>::clear_elements ()
{
- typename std::vector<std_cxx11::shared_ptr<Object> >::iterator v;
+ typename std::vector<std::shared_ptr<Object> >::iterator v;
for (v = objects.begin(); v != objects.end(); ++v)
(*v)->clear();
}
MGLevelObject<Object>::memory_consumption () const
{
std::size_t result = sizeof(*this);
- typedef typename std::vector<std_cxx11::shared_ptr<Object> >::const_iterator Iter;
+ typedef typename std::vector<std::shared_ptr<Object> >::const_iterator Iter;
const Iter end = objects.end();
for (Iter o=objects.begin(); o!=end; ++o)
result += (*o)->memory_consumption();
#include <deal.II/base/synchronous_iterator.h>
#include <deal.II/base/thread_management.h>
-#include <deal.II/base/std_cxx11/tuple.h>
-#include <deal.II/base/std_cxx11/bind.h>
-#include <deal.II/base/std_cxx11/function.h>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
-
#include <cstddef>
+#include <tuple>
+#include <memory>
+#include <functional>
#ifdef DEAL_II_WITH_THREADS
# include <tbb/parallel_for.h>
static
void
apply (const F &f,
- const std_cxx11::tuple<I1,I2> &p)
+ const std::tuple<I1,I2> &p)
{
- *std_cxx11::get<1>(p) = f (*std_cxx11::get<0>(p));
+ *std::get<1>(p) = f (*std::get<0>(p));
}
/**
static
void
apply (const F &f,
- const std_cxx11::tuple<I1,I2,I3> &p)
+ const std::tuple<I1,I2,I3> &p)
{
- *std_cxx11::get<2>(p) = f (*std_cxx11::get<0>(p),
- *std_cxx11::get<1>(p));
+ *std::get<2>(p) = f (*std::get<0>(p),
+ *std::get<1>(p));
}
/**
static
void
apply (const F &f,
- const std_cxx11::tuple<I1,I2,I3,I4> &p)
+ const std::tuple<I1,I2,I3,I4> &p)
{
- *std_cxx11::get<3>(p) = f (*std_cxx11::get<0>(p),
- *std_cxx11::get<1>(p),
- *std_cxx11::get<2>(p));
+ *std::get<3>(p) = f (*std::get<0>(p),
+ *std::get<1>(p),
+ *std::get<2>(p));
}
};
for (OutputIterator in = begin_in; in != end_in;)
*out++ = predicate (*in++);
#else
- typedef std_cxx11::tuple<InputIterator,OutputIterator> Iterators;
+ typedef std::tuple<InputIterator,OutputIterator> Iterators;
typedef SynchronousIterators<Iterators> SyncIterators;
Iterators x_begin (begin_in, out);
Iterators x_end (end_in, OutputIterator());
*out++ = predicate (*in1++, *in2++);
#else
typedef
- std_cxx11::tuple<InputIterator1,InputIterator2,OutputIterator>
+ std::tuple<InputIterator1,InputIterator2,OutputIterator>
Iterators;
typedef SynchronousIterators<Iterators> SyncIterators;
Iterators x_begin (begin_in1, in2, out);
*out++ = predicate (*in1++, *in2++, *in3++);
#else
typedef
- std_cxx11::tuple<InputIterator1,InputIterator2,InputIterator3,OutputIterator>
+ std::tuple<InputIterator1,InputIterator2,InputIterator3,OutputIterator>
Iterators;
typedef SynchronousIterators<Iterators> SyncIterators;
Iterators x_begin (begin_in1, in2, in3, out);
* {
* parallel::apply_to_subranges
* (0, A.n_rows(),
- * std_cxx11::bind (&mat_vec_on_subranges,
- * std_cxx11::_1, std_cxx11::_2,
- * std_cxx11::cref(A),
- * std_cxx11::cref(x),
- * std_cxx11::ref(y)),
+ * std::bind (&mat_vec_on_subranges,
+ * std::placeholders::_1, std::placeholders::_2,
+ * std::cref(A),
+ * std::cref(x),
+ * std::ref(y)),
* 50);
* }
*
* }
* @endcode
*
- * Note how we use the <code>std_cxx11::bind</code> function to convert
+ * Note how we use the <code>std::bind</code> function to convert
* <code>mat_vec_on_subranges</code> from a function that takes 5 arguments
* to one taking 2 by binding the remaining arguments (the modifiers
- * <code>std_cxx11::ref</code> and <code>std_cxx11::cref</code> make sure
+ * <code>std::ref</code> and <code>std::cref</code> make sure
* that the enclosed variables are actually passed by reference and constant
* reference, rather than by value). The resulting function object requires
* only two arguments, begin_row and end_row, with all other arguments
#else
tbb::parallel_for (tbb::blocked_range<RangeType>
(begin, end, grainsize),
- std_cxx11::bind (&internal::apply_to_subranges<RangeType,Function>,
- std_cxx11::_1,
- std_cxx11::cref(f)),
+ std::bind (&internal::apply_to_subranges<RangeType,Function>,
+ std::placeholders::_1,
+ std::cref(f)),
tbb::auto_partitioner());
#endif
}
* The function object to be used to reduce the result of two calls into
* one number.
*/
- const std_cxx11::function<ResultType (ResultType, ResultType)> reductor;
+ const std::function<ResultType (ResultType, ResultType)> reductor;
};
#endif
}
* std::sqrt
* (parallel::accumulate_from_subranges<double>
* (0, A.n_rows(),
- * std_cxx11::bind (&mat_norm_sqr_on_subranges,
- * std_cxx11::_1, std_cxx11::_2,
- * std_cxx11::cref(A),
- * std_cxx11::cref(x)),
+ * std::bind (&mat_norm_sqr_on_subranges,
+ * std::placeholders::_1, std::placeholders::_2,
+ * std::cref(A),
+ * std::cref(x)),
* 50);
* }
*
* released it yet, a new object is created. To free the partitioner
* again, return it by the release_one_partitioner() call.
*/
- std_cxx11::shared_ptr<tbb::affinity_partitioner>
+ std::shared_ptr<tbb::affinity_partitioner>
acquire_one_partitioner()
{
dealii::Threads::Mutex::ScopedLock lock(mutex);
if (in_use)
- return std_cxx11::shared_ptr<tbb::affinity_partitioner>(new tbb::affinity_partitioner());
+ return std::shared_ptr<tbb::affinity_partitioner>(new tbb::affinity_partitioner());
in_use = true;
return my_partitioner;
* acquire_one_partitioner(), this call makes the partitioner available
* again.
*/
- void release_one_partitioner(std_cxx11::shared_ptr<tbb::affinity_partitioner> &p)
+ void release_one_partitioner(std::shared_ptr<tbb::affinity_partitioner> &p)
{
if (p.get() == my_partitioner.get())
{
* The stored partitioner that can accumulate knowledge over several
* runs of tbb::parallel_for
*/
- std_cxx11::shared_ptr<tbb::affinity_partitioner> my_partitioner;
+ std::shared_ptr<tbb::affinity_partitioner> my_partitioner;
/**
* A flag to indicate whether the partitioner has been acquired but not
#include <deal.II/base/config.h>
#include <deal.II/base/exceptions.h>
#include <deal.II/base/subscriptor.h>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
-#include <deal.II/base/std_cxx11/unique_ptr.h>
#include <boost/property_tree/ptree_fwd.hpp>
#include <boost/serialization/split_member.hpp>
#include <map>
#include <vector>
#include <string>
+#include <memory>
DEAL_II_NAMESPACE_OPEN
* than having to include all of the property_tree stuff from boost. This
* works around a problem with gcc 4.5.
*/
- std_cxx11::unique_ptr<boost::property_tree::ptree> entries;
+ std::unique_ptr<boost::property_tree::ptree> entries;
/**
* A list of patterns that are used to describe the parameters of this
* object. The are indexed by nodes in the property tree.
*/
- std::vector<std_cxx11::shared_ptr<const Patterns::PatternBase> > patterns;
+ std::vector<std::shared_ptr<const Patterns::PatternBase> > patterns;
/**
* Mangle a string so that it doesn't contain any special characters or
*
* static void declare_parameters (ParameterHandler &prm);
* private:
- * std
_cxx11::shared_ptr<Problem> p;
+ * std::shared_ptr<Problem> p;
* };
*
*
patterns.clear ();
for (unsigned int j=0; j<descriptions.size(); ++j)
- patterns.push_back (std_cxx11::shared_ptr<const Patterns::PatternBase>(Patterns::pattern_factory(descriptions[j])));
+ patterns.push_back (std::shared_ptr<const Patterns::PatternBase>(Patterns::pattern_factory(descriptions[j])));
}
* a tensor (because it lacks the transformation properties under rotation of
* the coordinate system) and should consequently not be represented by either
* of these classes. Use an array of size 3 in this case, or the
- * <code>std_cxx11::array</code> class. Alternatively, as in the case of
+ * <code>std::array</code> class. Alternatively, as in the case of
* vector-valued functions, you can use objects of type Vector or
* <code>std::vector</code>.
*
#include <deal.II/base/exceptions.h>
#include <deal.II/base/subscriptor.h>
#include <deal.II/base/point.h>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
+#include <memory>
#include <vector>
DEAL_II_NAMESPACE_OPEN
* shared_ptr in order to correctly free the memory of the vectors when
* the global destructor is called.
*/
- static std::vector<std_cxx11::shared_ptr<const std::vector<double> > > recursive_coefficients;
+ static std::vector<std::shared_ptr<const std::vector<double> > > recursive_coefficients;
};
#include <deal.II/base/table.h>
#include <deal.II/base/thread_management.h>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
+#include <memory>
#include <vector>
DEAL_II_NAMESPACE_OPEN
data_size_in_bytes = sizeof(double) * dofs_per_cell * number_of_values;
offset = triangulation->register_data_attach(data_size_in_bytes,
- std_cxx11::bind(&ContinuousQuadratureDataTransfer<dim,DataType>::pack_function,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3));
+ std::bind(&ContinuousQuadratureDataTransfer<dim,DataType>::pack_function,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3));
}
void ContinuousQuadratureDataTransfer<dim,DataType>::interpolate ()
{
triangulation->notify_ready_to_unpack(offset,
- std_cxx11::bind(&ContinuousQuadratureDataTransfer<dim,DataType>::unpack_function,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3));
+ std::bind(&ContinuousQuadratureDataTransfer<dim,DataType>::unpack_function,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3));
// invalidate the pointers
data_storage = nullptr;
#include <deal.II/base/config.h>
-#ifdef DEAL_II_WITH_CXX11
# include <array>
DEAL_II_NAMESPACE_OPEN
}
DEAL_II_NAMESPACE_CLOSE
-#else
-
-#include <boost/array.hpp>
-DEAL_II_NAMESPACE_OPEN
-namespace std_cxx11
-{
- using boost::array;
-}
-DEAL_II_NAMESPACE_CLOSE
-
-#endif
-
// then allow using the old namespace name instead of the new one
DEAL_II_NAMESPACE_OPEN
namespace std_cxx1x = std_cxx11;
#include <deal.II/base/config.h>
-#ifdef DEAL_II_WITH_CXX11
# include <functional>
}
DEAL_II_NAMESPACE_CLOSE
-#else
-
-#include <boost/bind.hpp>
-
-DEAL_II_NAMESPACE_OPEN
-namespace std_cxx11
-{
- using boost::bind;
- using boost::ref;
- using boost::cref;
- using boost::reference_wrapper;
-
- // now also import the _1, _2 placeholders from the global namespace
- // into the current one as suggested above
- using ::_1;
- using ::_2;
- using ::_3;
- using ::_4;
- using ::_5;
- using ::_6;
- using ::_7;
- using ::_8;
- using ::_9;
-
- namespace placeholders
- {
- using ::_1;
- using ::_2;
- using ::_3;
- using ::_4;
- using ::_5;
- using ::_6;
- using ::_7;
- using ::_8;
- using ::_9;
- }
-}
-DEAL_II_NAMESPACE_CLOSE
-
-#endif
// then allow using the old namespace name instead of the new one
DEAL_II_NAMESPACE_OPEN
#include <deal.II/base/config.h>
-#ifdef DEAL_II_WITH_CXX11
-
# include <condition_variable>
DEAL_II_NAMESPACE_OPEN
namespace std_cxx11
}
DEAL_II_NAMESPACE_CLOSE
-#else
-
-# include <boost/thread/condition_variable.hpp>
-DEAL_II_NAMESPACE_OPEN
-namespace std_cxx11
-{
- using boost::condition_variable;
- using boost::unique_lock;
- using boost::adopt_lock;
-}
-DEAL_II_NAMESPACE_CLOSE
-
-#endif
-
// then allow using the old namespace name instead of the new one
DEAL_II_NAMESPACE_OPEN
namespace std_cxx1x = std_cxx11;
#include <deal.II/base/config.h>
-#ifdef DEAL_II_WITH_CXX11
# include <functional>
DEAL_II_NAMESPACE_OPEN
}
DEAL_II_NAMESPACE_CLOSE
-#else
-
-#include <boost/function.hpp>
-DEAL_II_NAMESPACE_OPEN
-namespace std_cxx11
-{
- using boost::function;
-}
-DEAL_II_NAMESPACE_CLOSE
-
-#endif
// then allow using the old namespace name instead of the new one
DEAL_II_NAMESPACE_OPEN
#include <deal.II/base/config.h>
-#ifdef DEAL_II_WITH_CXX11
-
# include <iterator>
DEAL_II_NAMESPACE_OPEN
namespace std_cxx11
}
DEAL_II_NAMESPACE_CLOSE
-#else
-
-#include <boost/range.hpp>
-DEAL_II_NAMESPACE_OPEN
-namespace std_cxx11
-{
- using boost::begin;
- using boost::end;
-}
-DEAL_II_NAMESPACE_CLOSE
-#endif
-
#endif
#include <deal.II/base/config.h>
-#ifdef DEAL_II_WITH_CXX11
-
# include <mutex>
DEAL_II_NAMESPACE_OPEN
namespace std_cxx11
}
DEAL_II_NAMESPACE_CLOSE
-#else
-
-# include <boost/thread/mutex.hpp>
-DEAL_II_NAMESPACE_OPEN
-namespace std_cxx11
-{
- using boost::mutex;
-}
-DEAL_II_NAMESPACE_CLOSE
-
-#endif
-
// then allow using the old namespace name instead of the new one
DEAL_II_NAMESPACE_OPEN
namespace std_cxx1x = std_cxx11;
#include <deal.II/base/config.h>
-#ifdef DEAL_II_WITH_CXX11
# include <memory>
DEAL_II_NAMESPACE_OPEN
}
DEAL_II_NAMESPACE_CLOSE
-#else
-
-#include <boost/shared_ptr.hpp>
-#include <boost/enable_shared_from_this.hpp>
-#include <boost/make_shared.hpp>
-DEAL_II_NAMESPACE_OPEN
-namespace std_cxx11
-{
- using boost::shared_ptr;
- using boost::enable_shared_from_this;
- using boost::make_shared;
- using boost::dynamic_pointer_cast;
-}
-DEAL_II_NAMESPACE_CLOSE
-
-#endif
// then allow using the old namespace name instead of the new one
DEAL_II_NAMESPACE_OPEN
#include <deal.II/base/config.h>
-#ifdef DEAL_II_WITH_CXX11
-
# include <thread>
DEAL_II_NAMESPACE_OPEN
namespace std_cxx11
}
DEAL_II_NAMESPACE_CLOSE
-#else
-
-DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
-# include <boost/thread.hpp>
-DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
-
-DEAL_II_NAMESPACE_OPEN
-namespace std_cxx11
-{
- using boost::thread;
-}
-DEAL_II_NAMESPACE_CLOSE
-
-#endif
-
// then allow using the old namespace name instead of the new one
DEAL_II_NAMESPACE_OPEN
namespace std_cxx1x = std_cxx11;
#include <deal.II/base/config.h>
-#ifdef DEAL_II_WITH_CXX11
-
# include <tuple>
DEAL_II_NAMESPACE_OPEN
namespace std_cxx11
}
DEAL_II_NAMESPACE_CLOSE
-#else
-
-#include <boost/tuple/tuple.hpp>
-DEAL_II_NAMESPACE_OPEN
-namespace std_cxx11
-{
- using boost::tuple;
- using boost::make_tuple;
- using boost::get;
-
- // boost::tuples::length has been renamed
- // by the standard to std::tuple_size
- template <typename T>
- struct tuple_size
- {
- static const std::size_t value = boost::tuples::length<T>::value;
- };
-
- // similarly, boost::tuples::element has
- // been renamed by the standard to
- // std::tuple_element
- template <int N, typename T>
- struct tuple_element
- {
- typedef typename boost::tuples::element<N,T>::type type;
- };
-}
-DEAL_II_NAMESPACE_CLOSE
-
-#endif
-
// then allow using the old namespace name instead of the new one
DEAL_II_NAMESPACE_OPEN
namespace std_cxx1x = std_cxx11;
#include <deal.II/base/config.h>
-#ifdef DEAL_II_WITH_CXX11
-
# include <type_traits>
DEAL_II_NAMESPACE_OPEN
namespace std_cxx11
}
DEAL_II_NAMESPACE_CLOSE
-#else
-
-DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
-#include <boost/type_traits.hpp>
-#include <boost/version.hpp>
-#if BOOST_VERSION<105600
-#include <boost/utility/enable_if.hpp>
-#else
-#include <boost/core/enable_if.hpp>
-#endif
-DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
-
-DEAL_II_NAMESPACE_OPEN
-namespace std_cxx11
-{
- using boost::is_fundamental;
- using boost::is_pod;
- using boost::is_pointer;
-
- // boost::enable_if_c, *not* boost::enable_if, is equivalent to std::enable_if.
- template <bool B, class T = void>
- struct enable_if : public boost::enable_if_c<B, T>
- {};
-
- // boost does not have is_standard_layout and
- // is_trivial, but those are both a subset of
- // is_pod
- template <typename T>
- struct is_standard_layout
- {
- static const bool value = boost::is_pod<T>::value;
- };
-
- template <typename T>
- struct is_trivial
- {
- static const bool value = boost::has_trivial_copy<T>::value &&
- boost::has_trivial_assign<T>::value &&
- boost::has_trivial_constructor<T>::value &&
- boost::has_trivial_destructor<T>::value;
- };
-
- using boost::true_type;
- using boost::false_type;
-}
-DEAL_II_NAMESPACE_CLOSE
-
-#endif
-
// then allow using the old namespace name instead of the new one
DEAL_II_NAMESPACE_OPEN
#include <deal.II/base/config.h>
-#ifdef DEAL_II_WITH_CXX11
# include <memory>
DEAL_II_NAMESPACE_OPEN
}
DEAL_II_NAMESPACE_CLOSE
-#else
-
-#include <boost/scoped_ptr.hpp>
-#include <boost/serialization/scoped_ptr.hpp>
-
-
-DEAL_II_NAMESPACE_OPEN
-namespace std_cxx11
-{
- /**
- * Implementation of a basic replacement for C++11's std::unique_ptr class.
- *
- * BOOST does not have a replacement for std::unique_ptr (because unique_ptr
- * requires move semantics that aren't available unless you have a C++11
- * compiler -- in which case you also have std::unique_ptr; see for example
- * http://stackoverflow.com/questions/2953530/unique-ptr-boost-equivalent)
- *
- * Consequently, we emulate the class by just wrapping a boost::scoped_ptr
- * in the cheapest possible way -- by just deriving from it and repeating
- * the basic constructors. Everything else is inherited from the scoped_ptr
- * class.
- *
- * There is no overhead to this approach: scoped_ptr cannot be copied or
- * moved. Instances of unique_ptr cannot be copied, and if you do not have a
- * C++11 compiler, then you cannot move anything anyway.
- */
- template <typename T>
- class unique_ptr : public boost::scoped_ptr<T>
- {
- public:
- unique_ptr () {}
-
- template<class Y>
- explicit unique_ptr (Y *p)
- :
- boost::scoped_ptr<T>(p)
- {}
- };
-
-
- template<class Archive, class T>
- void save(Archive &ar,
- const unique_ptr< T > &t,
- const unsigned int version)
- {
- boost::serialization::save (ar, static_cast<boost::scoped_ptr<T>&>(t), version);
- }
-
- template<class Archive, class T>
- void load(Archive &ar,
- unique_ptr< T > &t,
- const unsigned int version)
- {
- boost::serialization::load (ar, static_cast<boost::scoped_ptr<T>&>(t), version);
- }
-
- template<class Archive, class T>
- void serialize(Archive &ar,
- unique_ptr< T > &t,
- const unsigned int version)
- {
- boost::serialization::serialize (ar, static_cast<boost::scoped_ptr<T>&>(t), version);
- }
-
-}
-DEAL_II_NAMESPACE_CLOSE
-
-#endif
-
// then allow using the old namespace name instead of the new one
DEAL_II_NAMESPACE_OPEN
namespace std_cxx1x = std_cxx11;
#include <deal.II/base/config.h>
#include <deal.II/base/exceptions.h>
-#include <deal.II/base/std_cxx11/tuple.h>
#include <iterator>
+#include <tuple>
DEAL_II_NAMESPACE_OPEN
* not <code>b.end()</code>)
*
* The template argument of the current class shall be of type
- * <code>std_cxx11::tuple</code> with arguments equal to the iterator types.
+ * <code>std::tuple</code> with arguments equal to the iterator types.
*
* The individual iterators can be accessed using
- * <code>std_cxx11::get<X>(synchronous_iterator.iterators)</code> where X is
+ * <code>std::get<X>(synchronous_iterator.iterators)</code> where X is
* the number corresponding to the desired iterator.
*
* This type, and the helper functions associated with it, are used as the
operator< (const SynchronousIterators<Iterators> &a,
const SynchronousIterators<Iterators> &b)
{
- return std_cxx11::get<0>(*a) < std_cxx11::get<0>(*b);
+ return std::get<0>(*a) < std::get<0>(*b);
}
operator- (const SynchronousIterators<Iterators> &a,
const SynchronousIterators<Iterators> &b)
{
- Assert (std::distance (std_cxx11::get<0>(*b),
- std_cxx11::get<0>(*a)) >= 0,
+ Assert (std::distance (std::get<0>(*b),
+ std::get<0>(*a)) >= 0,
ExcInternalError());
- return std::distance (std_cxx11::get<0>(*b),
- std_cxx11::get<0>(*a));
+ return std::distance (std::get<0>(*b),
+ std::get<0>(*a));
}
*/
template <typename I1, typename I2>
inline
-void advance (std_cxx11::tuple<I1,I2> &t,
+void advance (std::tuple<I1,I2> &t,
const unsigned int n)
{
- std::advance (std_cxx11::get<0>(t), n);
- std::advance (std_cxx11::get<1>(t), n);
+ std::advance (std::get<0>(t), n);
+ std::advance (std::get<1>(t), n);
}
/**
*/
template <typename I1, typename I2, typename I3>
inline
-void advance (std_cxx11::tuple<I1,I2,I3> &t,
+void advance (std::tuple<I1,I2,I3> &t,
const unsigned int n)
{
- std::advance (std_cxx11::get<0>(t), n);
- std::advance (std_cxx11::get<1>(t), n);
- std::advance (std_cxx11::get<2>(t), n);
+ std::advance (std::get<0>(t), n);
+ std::advance (std::get<1>(t), n);
+ std::advance (std::get<2>(t), n);
}
/**
template <typename I1, typename I2,
typename I3, typename I4>
inline
-void advance (std_cxx11::tuple<I1,I2,I3, I4> &t,
+void advance (std::tuple<I1,I2,I3, I4> &t,
const unsigned int n)
{
- std::advance (std_cxx11::get<0>(t), n);
- std::advance (std_cxx11::get<1>(t), n);
- std::advance (std_cxx11::get<2>(t), n);
- std::advance (std_cxx11::get<3>(t), n);
+ std::advance (std::get<0>(t), n);
+ std::advance (std::get<1>(t), n);
+ std::advance (std::get<2>(t), n);
+ std::advance (std::get<3>(t), n);
}
*/
template <typename I1, typename I2>
inline
-void advance_by_one (std_cxx11::tuple<I1,I2> &t)
+void advance_by_one (std::tuple<I1,I2> &t)
{
- ++std_cxx11::get<0>(t);
- ++std_cxx11::get<1>(t);
+ ++std::get<0>(t);
+ ++std::get<1>(t);
}
/**
*/
template <typename I1, typename I2, typename I3>
inline
-void advance_by_one (std_cxx11::tuple<I1,I2,I3> &t)
+void advance_by_one (std::tuple<I1,I2,I3> &t)
{
- ++std_cxx11::get<0>(t);
- ++std_cxx11::get<1>(t);
- ++std_cxx11::get<2>(t);
+ ++std::get<0>(t);
+ ++std::get<1>(t);
+ ++std::get<2>(t);
}
/**
template <typename I1, typename I2,
typename I3, typename I4>
inline
-void advance_by_one (std_cxx11::tuple<I1,I2,I3,I4> &t)
+void advance_by_one (std::tuple<I1,I2,I3,I4> &t)
{
- ++std_cxx11::get<0>(t);
- ++std_cxx11::get<1>(t);
- ++std_cxx11::get<2>(t);
- ++std_cxx11::get<3>(t);
+ ++std::get<0>(t);
+ ++std::get<1>(t);
+ ++std::get<2>(t);
+ ++std::get<3>(t);
}
operator != (const SynchronousIterators<Iterators> &a,
const SynchronousIterators<Iterators> &b)
{
- return (std_cxx11::get<0>(*a) !=
- std_cxx11::get<0>(*b));
+ return (std::get<0>(*a) !=
+ std::get<0>(*b));
}
DEAL_II_NAMESPACE_CLOSE
#include <deal.II/base/config.h>
#include <deal.II/base/exceptions.h>
-#include <deal.II/base/std_cxx11/iterator.h>
#include <algorithm>
#include <ostream>
+#include <iterator>
DEAL_II_NAMESPACE_OPEN
void
TableIndices<N>::sort ()
{
- std::sort(std_cxx11::begin(indices), std_cxx11::end(indices));
+ std::sort(std::begin(indices), std::end(indices));
}
#include <deal.II/base/config.h>
#include <deal.II/base/exceptions.h>
#include <deal.II/base/template_constraints.h>
-#include <deal.II/base/std_cxx11/tuple.h>
-#include <deal.II/base/std_cxx11/function.h>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
-#include <deal.II/base/std_cxx11/bind.h>
#ifdef DEAL_II_WITH_THREADS
-# include <deal.II/base/std_cxx11/thread.h>
-# include <deal.II/base/std_cxx11/mutex.h>
-# include <deal.II/base/std_cxx11/condition_variable.h>
+# include <thread>
+# include <mutex>
+# include <condition_variable>
#endif
#include <iterator>
#include <vector>
#include <list>
#include <utility>
+#include <functional>
+#include <memory>
+#include <tuple>
#ifdef DEAL_II_WITH_THREADS
/**
* Data object storing the mutex data
*/
- std_cxx11::mutex mutex;
+ std::mutex mutex;
/**
* Make the class implementing condition variables a friend, since it
*/
inline void wait (Mutex &mutex)
{
- std_cxx11::unique_lock<std_cxx11::mutex> lock(mutex.mutex,
- std_cxx11::adopt_lock);
+ std::unique_lock<std::mutex> lock(mutex.mutex, std::adopt_lock);
condition_variable.wait (lock);
}
/**
* Data object storing the necessary data.
*/
- std_cxx11::condition_variable condition_variable;
+ std::condition_variable condition_variable;
};
namespace internal
{
template <typename RT>
- inline void call (const std_cxx11::function<RT ()> &function,
+ inline void call (const std::function<RT ()> &function,
internal::return_value<RT> &ret_val)
{
ret_val.set (function());
}
- inline void call (const std_cxx11::function<void ()> &function,
+ inline void call (const std::function<void ()> &function,
internal::return_value<void> &)
{
function();
* arguments.
*/
template <typename RT, typename ArgList,
- int length = std
_cxx11::tuple_size<ArgList>::value>
+ int length = std::tuple_size<ArgList>::value>
struct fun_ptr_helper;
template <typename RT, typename ArgList>
struct fun_ptr_helper<RT, ArgList, 1>
{
- typedef RT (type) (typename std_cxx11::tuple_element<0,ArgList>::type);
+ typedef RT (type) (typename std::tuple_element<0,ArgList>::type);
};
template <typename RT, typename ArgList>
struct fun_ptr_helper<RT, ArgList, 2>
{
- typedef RT (type) (typename std_cxx11::tuple_element<0,ArgList>::type,
- typename std_cxx11::tuple_element<1,ArgList>::type);
+ typedef RT (type) (typename std::tuple_element<0,ArgList>::type,
+ typename std::tuple_element<1,ArgList>::type);
};
template <typename RT, typename ArgList>
struct fun_ptr_helper<RT, ArgList, 3>
{
- typedef RT (type) (typename std_cxx11::tuple_element<0,ArgList>::type,
- typename std_cxx11::tuple_element<1,ArgList>::type,
- typename std_cxx11::tuple_element<2,ArgList>::type);
+ typedef RT (type) (typename std::tuple_element<0,ArgList>::type,
+ typename std::tuple_element<1,ArgList>::type,
+ typename std::tuple_element<2,ArgList>::type);
};
template <typename RT, typename ArgList>
struct fun_ptr_helper<RT, ArgList, 4>
{
- typedef RT (type) (typename std_cxx11::tuple_element<0,ArgList>::type,
- typename std_cxx11::tuple_element<1,ArgList>::type,
- typename std_cxx11::tuple_element<2,ArgList>::type,
- typename std_cxx11::tuple_element<3,ArgList>::type);
+ typedef RT (type) (typename std::tuple_element<0,ArgList>::type,
+ typename std::tuple_element<1,ArgList>::type,
+ typename std::tuple_element<2,ArgList>::type,
+ typename std::tuple_element<3,ArgList>::type);
};
template <typename RT, typename ArgList>
struct fun_ptr_helper<RT, ArgList, 5>
{
- typedef RT (type) (typename std_cxx11::tuple_element<0,ArgList>::type,
- typename std_cxx11::tuple_element<1,ArgList>::type,
- typename std_cxx11::tuple_element<2,ArgList>::type,
- typename std_cxx11::tuple_element<3,ArgList>::type,
- typename std_cxx11::tuple_element<4,ArgList>::type);
+ typedef RT (type) (typename std::tuple_element<0,ArgList>::type,
+ typename std::tuple_element<1,ArgList>::type,
+ typename std::tuple_element<2,ArgList>::type,
+ typename std::tuple_element<3,ArgList>::type,
+ typename std::tuple_element<4,ArgList>::type);
};
template <typename RT, typename ArgList>
struct fun_ptr_helper<RT, ArgList, 6>
{
- typedef RT (type) (typename std_cxx11::tuple_element<0,ArgList>::type,
- typename std_cxx11::tuple_element<1,ArgList>::type,
- typename std_cxx11::tuple_element<2,ArgList>::type,
- typename std_cxx11::tuple_element<3,ArgList>::type,
- typename std_cxx11::tuple_element<4,ArgList>::type,
- typename std_cxx11::tuple_element<5,ArgList>::type);
+ typedef RT (type) (typename std::tuple_element<0,ArgList>::type,
+ typename std::tuple_element<1,ArgList>::type,
+ typename std::tuple_element<2,ArgList>::type,
+ typename std::tuple_element<3,ArgList>::type,
+ typename std::tuple_element<4,ArgList>::type,
+ typename std::tuple_element<5,ArgList>::type);
};
template <typename RT, typename ArgList>
struct fun_ptr_helper<RT, ArgList, 7>
{
- typedef RT (type) (typename std_cxx11::tuple_element<0,ArgList>::type,
- typename std_cxx11::tuple_element<1,ArgList>::type,
- typename std_cxx11::tuple_element<2,ArgList>::type,
- typename std_cxx11::tuple_element<3,ArgList>::type,
- typename std_cxx11::tuple_element<4,ArgList>::type,
- typename std_cxx11::tuple_element<5,ArgList>::type,
- typename std_cxx11::tuple_element<6,ArgList>::type);
+ typedef RT (type) (typename std::tuple_element<0,ArgList>::type,
+ typename std::tuple_element<1,ArgList>::type,
+ typename std::tuple_element<2,ArgList>::type,
+ typename std::tuple_element<3,ArgList>::type,
+ typename std::tuple_element<4,ArgList>::type,
+ typename std::tuple_element<5,ArgList>::type,
+ typename std::tuple_element<6,ArgList>::type);
};
template <typename RT, typename ArgList>
struct fun_ptr_helper<RT, ArgList, 8>
{
- typedef RT (type) (typename std_cxx11::tuple_element<0,ArgList>::type,
- typename std_cxx11::tuple_element<1,ArgList>::type,
- typename std_cxx11::tuple_element<2,ArgList>::type,
- typename std_cxx11::tuple_element<3,ArgList>::type,
- typename std_cxx11::tuple_element<4,ArgList>::type,
- typename std_cxx11::tuple_element<5,ArgList>::type,
- typename std_cxx11::tuple_element<6,ArgList>::type,
- typename std_cxx11::tuple_element<7,ArgList>::type);
+ typedef RT (type) (typename std::tuple_element<0,ArgList>::type,
+ typename std::tuple_element<1,ArgList>::type,
+ typename std::tuple_element<2,ArgList>::type,
+ typename std::tuple_element<3,ArgList>::type,
+ typename std::tuple_element<4,ArgList>::type,
+ typename std::tuple_element<5,ArgList>::type,
+ typename std::tuple_element<6,ArgList>::type,
+ typename std::tuple_element<7,ArgList>::type);
};
template <typename RT, typename ArgList>
struct fun_ptr_helper<RT, ArgList, 9>
{
- typedef RT (type) (typename std_cxx11::tuple_element<0,ArgList>::type,
- typename std_cxx11::tuple_element<1,ArgList>::type,
- typename std_cxx11::tuple_element<2,ArgList>::type,
- typename std_cxx11::tuple_element<3,ArgList>::type,
- typename std_cxx11::tuple_element<4,ArgList>::type,
- typename std_cxx11::tuple_element<5,ArgList>::type,
- typename std_cxx11::tuple_element<6,ArgList>::type,
- typename std_cxx11::tuple_element<7,ArgList>::type,
- typename std_cxx11::tuple_element<8,ArgList>::type);
+ typedef RT (type) (typename std::tuple_element<0,ArgList>::type,
+ typename std::tuple_element<1,ArgList>::type,
+ typename std::tuple_element<2,ArgList>::type,
+ typename std::tuple_element<3,ArgList>::type,
+ typename std::tuple_element<4,ArgList>::type,
+ typename std::tuple_element<5,ArgList>::type,
+ typename std::tuple_element<6,ArgList>::type,
+ typename std::tuple_element<7,ArgList>::type,
+ typename std::tuple_element<8,ArgList>::type);
};
template <typename RT, typename ArgList>
struct fun_ptr_helper<RT, ArgList, 10>
{
- typedef RT (type) (typename std_cxx11::tuple_element<0,ArgList>::type,
- typename std_cxx11::tuple_element<1,ArgList>::type,
- typename std_cxx11::tuple_element<2,ArgList>::type,
- typename std_cxx11::tuple_element<3,ArgList>::type,
- typename std_cxx11::tuple_element<4,ArgList>::type,
- typename std_cxx11::tuple_element<5,ArgList>::type,
- typename std_cxx11::tuple_element<6,ArgList>::type,
- typename std_cxx11::tuple_element<7,ArgList>::type,
- typename std_cxx11::tuple_element<8,ArgList>::type,
- typename std_cxx11::tuple_element<9,ArgList>::type);
+ typedef RT (type) (typename std::tuple_element<0,ArgList>::type,
+ typename std::tuple_element<1,ArgList>::type,
+ typename std::tuple_element<2,ArgList>::type,
+ typename std::tuple_element<3,ArgList>::type,
+ typename std::tuple_element<4,ArgList>::type,
+ typename std::tuple_element<5,ArgList>::type,
+ typename std::tuple_element<6,ArgList>::type,
+ typename std::tuple_element<7,ArgList>::type,
+ typename std::tuple_element<8,ArgList>::type,
+ typename std::tuple_element<9,ArgList>::type);
};
/**
* An object that represents the thread started.
*/
- std_cxx11::thread thread;
+ std::thread thread;
/**
* An object that will hold the value returned by the function called on
* the the ThreadDescriptor. This makes sure the object stays alive
* until the thread exits.
*/
- std_cxx11::shared_ptr<return_value<RT> > ret_val;
+ std::shared_ptr<return_value<RT> > ret_val;
/**
* A bool variable that is initially false, is set to true when a new
* Start the thread and let it put its return value into the ret_val
* object.
*/
- void start (const std_cxx11::function<RT ()> &function)
+ void start (const std::function<RT ()> &function)
{
thread_is_active = true;
ret_val.reset(new return_value<RT>());
- thread = std_cxx11::thread (thread_entry_point, function, ret_val);
+ thread = std::thread (thread_entry_point, function, ret_val);
}
* The function that runs on the thread.
*/
static
- void thread_entry_point (const std_cxx11::function<RT ()> function,
- std_cxx11::shared_ptr<return_value<RT> > ret_val)
+ void thread_entry_point (const std::function<RT ()> function,
+ std::shared_ptr<return_value<RT> > ret_val)
{
// call the function in question. since an exception that is
// thrown from one of the called functions will not propagate
* An object that will hold the value returned by the function called on
* the thread.
*/
- std_cxx11::shared_ptr<return_value<RT> > ret_val;
+ std::shared_ptr<return_value<RT> > ret_val;
/**
* Start the thread and let it put its return value into the ret_val
* object.
*/
- void start (const std_cxx11::function<RT ()> &function)
+ void start (const std::function<RT ()> &function)
{
ret_val.reset(new return_value<RT>());
call (function, *ret_val);
/**
* Construct a thread object with a function object.
*/
- Thread (const std_cxx11::function<RT ()> &function)
+ Thread (const std::function<RT ()> &function)
:
thread_descriptor (new internal::ThreadDescriptor<RT>())
{
* implementation will make sure that that object lives as long as there
* is at least one subscriber to it.
*/
- std_cxx11::shared_ptr<internal::ThreadDescriptor<RT> > thread_descriptor;
+ std::shared_ptr<internal::ThreadDescriptor<RT> > thread_descriptor;
};
namespace internal
{
/**
- * A general template that returns std_cxx11::ref(t) if t is of reference
+ * A general template that returns std::ref(t) if t is of reference
* type, and t otherwise.
*
* The case that t is of reference type is handled in a partial
/**
- * A general template that returns std_cxx11::ref(t) if t is of reference
+ * A general template that returns std::ref(t) if t is of reference
* type, and t otherwise.
*
* The case that t is of reference type is handled in this partial
template <typename T>
struct maybe_make_ref<T &>
{
- static std_cxx11::reference_wrapper<T> act (T &t)
+ static std::reference_wrapper<T> act (T &t)
{
- return std_cxx11::ref(t);
+ return std::ref(t);
}
};
}
: function (*function)
{}
- fun_encapsulator (const std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
+ fun_encapsulator (const std::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
: function (function)
{}
}
private:
- std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> function;
+ std::function<typename internal::fun_ptr<RT,ArgList>::type> function;
};
/**
: function (*function)
{}
- fun_encapsulator (const std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
+ fun_encapsulator (const std::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
: function (function)
{}
inline
Thread<RT>
- operator() (typename std_cxx11::tuple_element<0,ArgList>::type arg1)
+ operator() (typename std::tuple_element<0,ArgList>::type arg1)
{
return
Thread<RT>
- (std_cxx11::bind (function,
- internal::maybe_make_ref<typename std_cxx11::tuple_element<0,ArgList>::type>::act(arg1)));
+ (std::bind (function,
+ internal::maybe_make_ref<typename std::tuple_element<0,ArgList>::type>::act(arg1)));
}
private:
- std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> function;
+ std::function<typename internal::fun_ptr<RT,ArgList>::type> function;
};
/**
: function (*function)
{}
- fun_encapsulator (const std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
+ fun_encapsulator (const std::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
: function (function)
{}
inline
Thread<RT>
- operator() (typename std_cxx11::tuple_element<0,ArgList>::type arg1,
- typename std_cxx11::tuple_element<1,ArgList>::type arg2)
+ operator() (typename std::tuple_element<0,ArgList>::type arg1,
+ typename std::tuple_element<1,ArgList>::type arg2)
{
return
Thread<RT>
- (std_cxx11::bind (function,
- internal::maybe_make_ref<typename std_cxx11::tuple_element<0,ArgList>::type>::act(arg1),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<1,ArgList>::type>::act(arg2)));
+ (std::bind (function,
+ internal::maybe_make_ref<typename std::tuple_element<0,ArgList>::type>::act(arg1),
+ internal::maybe_make_ref<typename std::tuple_element<1,ArgList>::type>::act(arg2)));
}
private:
- std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> function;
+ std::function<typename internal::fun_ptr<RT,ArgList>::type> function;
};
/**
: function (*function)
{}
- fun_encapsulator (const std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
+ fun_encapsulator (const std::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
: function (function)
{}
inline
Thread<RT>
- operator() (typename std_cxx11::tuple_element<0,ArgList>::type arg1,
- typename std_cxx11::tuple_element<1,ArgList>::type arg2,
- typename std_cxx11::tuple_element<2,ArgList>::type arg3)
+ operator() (typename std::tuple_element<0,ArgList>::type arg1,
+ typename std::tuple_element<1,ArgList>::type arg2,
+ typename std::tuple_element<2,ArgList>::type arg3)
{
return
Thread<RT>
- (std_cxx11::bind (function,
- internal::maybe_make_ref<typename std_cxx11::tuple_element<0,ArgList>::type>::act(arg1),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<1,ArgList>::type>::act(arg2),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<2,ArgList>::type>::act(arg3)));
+ (std::bind (function,
+ internal::maybe_make_ref<typename std::tuple_element<0,ArgList>::type>::act(arg1),
+ internal::maybe_make_ref<typename std::tuple_element<1,ArgList>::type>::act(arg2),
+ internal::maybe_make_ref<typename std::tuple_element<2,ArgList>::type>::act(arg3)));
}
private:
- std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> function;
+ std::function<typename internal::fun_ptr<RT,ArgList>::type> function;
};
/**
: function (*function)
{}
- fun_encapsulator (const std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
+ fun_encapsulator (const std::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
: function (function)
{}
inline
Thread<RT>
- operator() (typename std_cxx11::tuple_element<0,ArgList>::type arg1,
- typename std_cxx11::tuple_element<1,ArgList>::type arg2,
- typename std_cxx11::tuple_element<2,ArgList>::type arg3,
- typename std_cxx11::tuple_element<3,ArgList>::type arg4)
+ operator() (typename std::tuple_element<0,ArgList>::type arg1,
+ typename std::tuple_element<1,ArgList>::type arg2,
+ typename std::tuple_element<2,ArgList>::type arg3,
+ typename std::tuple_element<3,ArgList>::type arg4)
{
return
Thread<RT>
- (std_cxx11::bind (function,
- internal::maybe_make_ref<typename std_cxx11::tuple_element<0,ArgList>::type>::act(arg1),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<1,ArgList>::type>::act(arg2),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<2,ArgList>::type>::act(arg3),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<3,ArgList>::type>::act(arg4)));
+ (std::bind (function,
+ internal::maybe_make_ref<typename std::tuple_element<0,ArgList>::type>::act(arg1),
+ internal::maybe_make_ref<typename std::tuple_element<1,ArgList>::type>::act(arg2),
+ internal::maybe_make_ref<typename std::tuple_element<2,ArgList>::type>::act(arg3),
+ internal::maybe_make_ref<typename std::tuple_element<3,ArgList>::type>::act(arg4)));
}
private:
- std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> function;
+ std::function<typename internal::fun_ptr<RT,ArgList>::type> function;
};
/**
: function (*function)
{}
- fun_encapsulator (const std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
+ fun_encapsulator (const std::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
: function (function)
{}
inline
Thread<RT>
- operator() (typename std_cxx11::tuple_element<0,ArgList>::type arg1,
- typename std_cxx11::tuple_element<1,ArgList>::type arg2,
- typename std_cxx11::tuple_element<2,ArgList>::type arg3,
- typename std_cxx11::tuple_element<3,ArgList>::type arg4,
- typename std_cxx11::tuple_element<4,ArgList>::type arg5)
+ operator() (typename std::tuple_element<0,ArgList>::type arg1,
+ typename std::tuple_element<1,ArgList>::type arg2,
+ typename std::tuple_element<2,ArgList>::type arg3,
+ typename std::tuple_element<3,ArgList>::type arg4,
+ typename std::tuple_element<4,ArgList>::type arg5)
{
return
Thread<RT>
- (std_cxx11::bind (function,
- internal::maybe_make_ref<typename std_cxx11::tuple_element<0,ArgList>::type>::act(arg1),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<1,ArgList>::type>::act(arg2),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<2,ArgList>::type>::act(arg3),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<3,ArgList>::type>::act(arg4),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<4,ArgList>::type>::act(arg5)));
+ (std::bind (function,
+ internal::maybe_make_ref<typename std::tuple_element<0,ArgList>::type>::act(arg1),
+ internal::maybe_make_ref<typename std::tuple_element<1,ArgList>::type>::act(arg2),
+ internal::maybe_make_ref<typename std::tuple_element<2,ArgList>::type>::act(arg3),
+ internal::maybe_make_ref<typename std::tuple_element<3,ArgList>::type>::act(arg4),
+ internal::maybe_make_ref<typename std::tuple_element<4,ArgList>::type>::act(arg5)));
}
private:
- std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> function;
+ std::function<typename internal::fun_ptr<RT,ArgList>::type> function;
};
/**
: function (*function)
{}
- fun_encapsulator (const std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
+ fun_encapsulator (const std::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
: function (function)
{}
inline
Thread<RT>
- operator() (typename std_cxx11::tuple_element<0,ArgList>::type arg1,
- typename std_cxx11::tuple_element<1,ArgList>::type arg2,
- typename std_cxx11::tuple_element<2,ArgList>::type arg3,
- typename std_cxx11::tuple_element<3,ArgList>::type arg4,
- typename std_cxx11::tuple_element<4,ArgList>::type arg5,
- typename std_cxx11::tuple_element<5,ArgList>::type arg6)
+ operator() (typename std::tuple_element<0,ArgList>::type arg1,
+ typename std::tuple_element<1,ArgList>::type arg2,
+ typename std::tuple_element<2,ArgList>::type arg3,
+ typename std::tuple_element<3,ArgList>::type arg4,
+ typename std::tuple_element<4,ArgList>::type arg5,
+ typename std::tuple_element<5,ArgList>::type arg6)
{
return
Thread<RT>
- (std_cxx11::bind (function,
- internal::maybe_make_ref<typename std_cxx11::tuple_element<0,ArgList>::type>::act(arg1),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<1,ArgList>::type>::act(arg2),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<2,ArgList>::type>::act(arg3),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<3,ArgList>::type>::act(arg4),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<4,ArgList>::type>::act(arg5),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<5,ArgList>::type>::act(arg6)));
+ (std::bind (function,
+ internal::maybe_make_ref<typename std::tuple_element<0,ArgList>::type>::act(arg1),
+ internal::maybe_make_ref<typename std::tuple_element<1,ArgList>::type>::act(arg2),
+ internal::maybe_make_ref<typename std::tuple_element<2,ArgList>::type>::act(arg3),
+ internal::maybe_make_ref<typename std::tuple_element<3,ArgList>::type>::act(arg4),
+ internal::maybe_make_ref<typename std::tuple_element<4,ArgList>::type>::act(arg5),
+ internal::maybe_make_ref<typename std::tuple_element<5,ArgList>::type>::act(arg6)));
}
private:
- std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> function;
+ std::function<typename internal::fun_ptr<RT,ArgList>::type> function;
};
/**
: function (*function)
{}
- fun_encapsulator (const std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
+ fun_encapsulator (const std::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
: function (function)
{}
inline
Thread<RT>
- operator() (typename std_cxx11::tuple_element<0,ArgList>::type arg1,
- typename std_cxx11::tuple_element<1,ArgList>::type arg2,
- typename std_cxx11::tuple_element<2,ArgList>::type arg3,
- typename std_cxx11::tuple_element<3,ArgList>::type arg4,
- typename std_cxx11::tuple_element<4,ArgList>::type arg5,
- typename std_cxx11::tuple_element<5,ArgList>::type arg6,
- typename std_cxx11::tuple_element<6,ArgList>::type arg7)
+ operator() (typename std::tuple_element<0,ArgList>::type arg1,
+ typename std::tuple_element<1,ArgList>::type arg2,
+ typename std::tuple_element<2,ArgList>::type arg3,
+ typename std::tuple_element<3,ArgList>::type arg4,
+ typename std::tuple_element<4,ArgList>::type arg5,
+ typename std::tuple_element<5,ArgList>::type arg6,
+ typename std::tuple_element<6,ArgList>::type arg7)
{
return
Thread<RT>
- (std_cxx11::bind (function,
- internal::maybe_make_ref<typename std_cxx11::tuple_element<0,ArgList>::type>::act(arg1),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<1,ArgList>::type>::act(arg2),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<2,ArgList>::type>::act(arg3),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<3,ArgList>::type>::act(arg4),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<4,ArgList>::type>::act(arg5),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<5,ArgList>::type>::act(arg6),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<6,ArgList>::type>::act(arg7)));
+ (std::bind (function,
+ internal::maybe_make_ref<typename std::tuple_element<0,ArgList>::type>::act(arg1),
+ internal::maybe_make_ref<typename std::tuple_element<1,ArgList>::type>::act(arg2),
+ internal::maybe_make_ref<typename std::tuple_element<2,ArgList>::type>::act(arg3),
+ internal::maybe_make_ref<typename std::tuple_element<3,ArgList>::type>::act(arg4),
+ internal::maybe_make_ref<typename std::tuple_element<4,ArgList>::type>::act(arg5),
+ internal::maybe_make_ref<typename std::tuple_element<5,ArgList>::type>::act(arg6),
+ internal::maybe_make_ref<typename std::tuple_element<6,ArgList>::type>::act(arg7)));
}
private:
- std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> function;
+ std::function<typename internal::fun_ptr<RT,ArgList>::type> function;
};
/**
: function (*function)
{}
- fun_encapsulator (const std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
+ fun_encapsulator (const std::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
: function (function)
{}
inline
Thread<RT>
- operator() (typename std_cxx11::tuple_element<0,ArgList>::type arg1,
- typename std_cxx11::tuple_element<1,ArgList>::type arg2,
- typename std_cxx11::tuple_element<2,ArgList>::type arg3,
- typename std_cxx11::tuple_element<3,ArgList>::type arg4,
- typename std_cxx11::tuple_element<4,ArgList>::type arg5,
- typename std_cxx11::tuple_element<5,ArgList>::type arg6,
- typename std_cxx11::tuple_element<6,ArgList>::type arg7,
- typename std_cxx11::tuple_element<7,ArgList>::type arg8)
+ operator() (typename std::tuple_element<0,ArgList>::type arg1,
+ typename std::tuple_element<1,ArgList>::type arg2,
+ typename std::tuple_element<2,ArgList>::type arg3,
+ typename std::tuple_element<3,ArgList>::type arg4,
+ typename std::tuple_element<4,ArgList>::type arg5,
+ typename std::tuple_element<5,ArgList>::type arg6,
+ typename std::tuple_element<6,ArgList>::type arg7,
+ typename std::tuple_element<7,ArgList>::type arg8)
{
return
Thread<RT>
- (std_cxx11::bind (function,
- internal::maybe_make_ref<typename std_cxx11::tuple_element<0,ArgList>::type>::act(arg1),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<1,ArgList>::type>::act(arg2),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<2,ArgList>::type>::act(arg3),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<3,ArgList>::type>::act(arg4),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<4,ArgList>::type>::act(arg5),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<5,ArgList>::type>::act(arg6),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<6,ArgList>::type>::act(arg7),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<7,ArgList>::type>::act(arg8)));
+ (std::bind (function,
+ internal::maybe_make_ref<typename std::tuple_element<0,ArgList>::type>::act(arg1),
+ internal::maybe_make_ref<typename std::tuple_element<1,ArgList>::type>::act(arg2),
+ internal::maybe_make_ref<typename std::tuple_element<2,ArgList>::type>::act(arg3),
+ internal::maybe_make_ref<typename std::tuple_element<3,ArgList>::type>::act(arg4),
+ internal::maybe_make_ref<typename std::tuple_element<4,ArgList>::type>::act(arg5),
+ internal::maybe_make_ref<typename std::tuple_element<5,ArgList>::type>::act(arg6),
+ internal::maybe_make_ref<typename std::tuple_element<6,ArgList>::type>::act(arg7),
+ internal::maybe_make_ref<typename std::tuple_element<7,ArgList>::type>::act(arg8)));
}
private:
- std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> function;
+ std::function<typename internal::fun_ptr<RT,ArgList>::type> function;
};
/**
: function (*function)
{}
- fun_encapsulator (const std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
+ fun_encapsulator (const std::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
: function (function)
{}
inline
Thread<RT>
- operator() (typename std_cxx11::tuple_element<0,ArgList>::type arg1,
- typename std_cxx11::tuple_element<1,ArgList>::type arg2,
- typename std_cxx11::tuple_element<2,ArgList>::type arg3,
- typename std_cxx11::tuple_element<3,ArgList>::type arg4,
- typename std_cxx11::tuple_element<4,ArgList>::type arg5,
- typename std_cxx11::tuple_element<5,ArgList>::type arg6,
- typename std_cxx11::tuple_element<6,ArgList>::type arg7,
- typename std_cxx11::tuple_element<7,ArgList>::type arg8,
- typename std_cxx11::tuple_element<8,ArgList>::type arg9)
+ operator() (typename std::tuple_element<0,ArgList>::type arg1,
+ typename std::tuple_element<1,ArgList>::type arg2,
+ typename std::tuple_element<2,ArgList>::type arg3,
+ typename std::tuple_element<3,ArgList>::type arg4,
+ typename std::tuple_element<4,ArgList>::type arg5,
+ typename std::tuple_element<5,ArgList>::type arg6,
+ typename std::tuple_element<6,ArgList>::type arg7,
+ typename std::tuple_element<7,ArgList>::type arg8,
+ typename std::tuple_element<8,ArgList>::type arg9)
{
return
Thread<RT>
- (std_cxx11::bind (function,
- internal::maybe_make_ref<typename std_cxx11::tuple_element<0,ArgList>::type>::act(arg1),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<1,ArgList>::type>::act(arg2),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<2,ArgList>::type>::act(arg3),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<3,ArgList>::type>::act(arg4),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<4,ArgList>::type>::act(arg5),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<5,ArgList>::type>::act(arg6),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<6,ArgList>::type>::act(arg7),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<7,ArgList>::type>::act(arg8),
- internal::maybe_make_ref<typename std_cxx11::tuple_element<8,ArgList>::type>::act(arg9)));
+ (std::bind (function,
+ internal::maybe_make_ref<typename std::tuple_element<0,ArgList>::type>::act(arg1),
+ internal::maybe_make_ref<typename std::tuple_element<1,ArgList>::type>::act(arg2),
+ internal::maybe_make_ref<typename std::tuple_element<2,ArgList>::type>::act(arg3),
+ internal::maybe_make_ref<typename std::tuple_element<3,ArgList>::type>::act(arg4),
+ internal::maybe_make_ref<typename std::tuple_element<4,ArgList>::type>::act(arg5),
+ internal::maybe_make_ref<typename std::tuple_element<5,ArgList>::type>::act(arg6),
+ internal::maybe_make_ref<typename std::tuple_element<6,ArgList>::type>::act(arg7),
+ internal::maybe_make_ref<typename std::tuple_element<7,ArgList>::type>::act(arg8),
+ internal::maybe_make_ref<typename std::tuple_element<8,ArgList>::type>::act(arg9)));
}
private:
- std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> function;
+ std::function<typename internal::fun_ptr<RT,ArgList>::type> function;
};
}
/**
* Overload of the new_thread function for objects that can be converted to
- * std_cxx11::function<RT ()>, i.e. anything that can be called like a
+ * std::function<RT ()>, i.e. anything that can be called like a
* function object without arguments and returning an object of type RT (or
* void).
*
template <typename RT>
inline
Thread<RT>
- new_thread (const std_cxx11::function<RT ()> &function)
+ new_thread (const std::function<RT ()> &function)
{
return Thread<RT>(function);
}
-> Thread<decltype(function_object())>
{
typedef decltype(function_object()) return_type;
- return Thread<return_type>(std_cxx11::function<return_type ()>(function_object));
+ return Thread<return_type>(std::function<return_type ()>(function_object));
}
#endif
Thread<RT>
new_thread (RT (*fun_ptr)())
{
- return new_thread (std_cxx11::function<RT ()> (fun_ptr));
+ return new_thread (std::function<RT ()> (fun_ptr));
}
typename identity<C>::type &c)
{
return
- new_thread (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::ref(c))));
+ new_thread (std::function<RT ()>
+ (std::bind(fun_ptr, std::ref(c))));
}
const typename identity<C>::type &c)
{
return
- new_thread (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::cref(c))));
+ new_thread (std::function<RT ()>
+ (std::bind(fun_ptr, std::cref(c))));
}
#endif
typename identity<Arg1>::type arg1)
{
return
- new_thread (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr,
-
internal::maybe_make_ref<Arg1>::act(arg1))));
+ new_thread (std::function<RT ()>
+ (std::bind(fun_ptr,
+ internal::maybe_make_ref<Arg1>::act(arg1))));
}
typename identity<Arg1>::type arg1)
{
return
- new_thread (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::ref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1))));
+ new_thread (std::function<RT ()>
+ (std::bind(fun_ptr, std::ref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1))));
}
#ifndef DEAL_II_CONST_MEMBER_DEDUCTION_BUG
typename identity<Arg1>::type arg1)
{
return
- new_thread (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::cref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1))));
+ new_thread (std::function<RT ()>
+ (std::bind(fun_ptr, std::cref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1))));
}
#endif
typename identity<Arg2>::type arg2)
{
return
- new_thread (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr,
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2))));
+ new_thread (std::function<RT ()>
+ (std::bind(fun_ptr,
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2))));
}
typename identity<Arg2>::type arg2)
{
return
- new_thread (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::ref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2))));
+ new_thread (std::function<RT ()>
+ (std::bind(fun_ptr, std::ref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2))));
}
#ifndef DEAL_II_CONST_MEMBER_DEDUCTION_BUG
typename identity<Arg2>::type arg2)
{
return
- new_thread (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::cref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2))));
+ new_thread (std::function<RT ()>
+ (std::bind(fun_ptr, std::cref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2))));
}
#endif
typename identity<Arg3>::type arg3)
{
return
- new_thread (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr,
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3))));
+ new_thread (std::function<RT ()>
+ (std::bind(fun_ptr,
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3))));
}
typename identity<Arg3>::type arg3)
{
return
- new_thread (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::ref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3))));
+ new_thread (std::function<RT ()>
+ (std::bind(fun_ptr, std::ref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3))));
}
#ifndef DEAL_II_CONST_MEMBER_DEDUCTION_BUG
typename identity<Arg3>::type arg3)
{
return
- new_thread (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::cref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3))));
+ new_thread (std::function<RT ()>
+ (std::bind(fun_ptr, std::cref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3))));
}
#endif
typename identity<Arg4>::type arg4)
{
return
- new_thread (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr,
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4))));
+ new_thread (std::function<RT ()>
+ (std::bind(fun_ptr,
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4))));
}
typename identity<Arg4>::type arg4)
{
return
- new_thread (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::ref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4))));
+ new_thread (std::function<RT ()>
+ (std::bind(fun_ptr, std::ref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4))));
}
#ifndef DEAL_II_CONST_MEMBER_DEDUCTION_BUG
typename identity<Arg4>::type arg4)
{
return
- new_thread (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::cref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4))));
+ new_thread (std::function<RT ()>
+ (std::bind(fun_ptr, std::cref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4))));
}
#endif
typename identity<Arg5>::type arg5)
{
return
- new_thread (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr,
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4),
-
internal::maybe_make_ref<Arg5>::act(arg5))));
+ new_thread (std::function<RT ()>
+ (std::bind(fun_ptr,
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4),
+ internal::maybe_make_ref<Arg5>::act(arg5))));
}
typename identity<Arg5>::type arg5)
{
return
- new_thread (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::ref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4),
-
internal::maybe_make_ref<Arg5>::act(arg5))));
+ new_thread (std::function<RT ()>
+ (std::bind(fun_ptr, std::ref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4),
+ internal::maybe_make_ref<Arg5>::act(arg5))));
}
#ifndef DEAL_II_CONST_MEMBER_DEDUCTION_BUG
typename identity<Arg5>::type arg5)
{
return
- new_thread (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::cref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4),
-
internal::maybe_make_ref<Arg5>::act(arg5))));
+ new_thread (std::function<RT ()>
+ (std::bind(fun_ptr, std::cref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4),
+ internal::maybe_make_ref<Arg5>::act(arg5))));
}
#endif
typename identity<Arg6>::type arg6)
{
return
- new_thread (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr,
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4),
-
internal::maybe_make_ref<Arg5>::act(arg5),
-
internal::maybe_make_ref<Arg6>::act(arg6))));
+ new_thread (std::function<RT ()>
+ (std::bind(fun_ptr,
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4),
+ internal::maybe_make_ref<Arg5>::act(arg5),
+ internal::maybe_make_ref<Arg6>::act(arg6))));
}
typename identity<Arg6>::type arg6)
{
return
- new_thread (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::ref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4),
-
internal::maybe_make_ref<Arg5>::act(arg5),
-
internal::maybe_make_ref<Arg6>::act(arg6))));
+ new_thread (std::function<RT ()>
+ (std::bind(fun_ptr, std::ref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4),
+ internal::maybe_make_ref<Arg5>::act(arg5),
+ internal::maybe_make_ref<Arg6>::act(arg6))));
}
#ifndef DEAL_II_CONST_MEMBER_DEDUCTION_BUG
typename identity<Arg6>::type arg6)
{
return
- new_thread (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::cref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4),
-
internal::maybe_make_ref<Arg5>::act(arg5),
-
internal::maybe_make_ref<Arg6>::act(arg6))));
+ new_thread (std::function<RT ()>
+ (std::bind(fun_ptr, std::cref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4),
+ internal::maybe_make_ref<Arg5>::act(arg5),
+ internal::maybe_make_ref<Arg6>::act(arg6))));
}
#endif
typename identity<Arg7>::type arg7)
{
return
- new_thread (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr,
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4),
-
internal::maybe_make_ref<Arg5>::act(arg5),
-
internal::maybe_make_ref<Arg6>::act(arg6),
-
internal::maybe_make_ref<Arg7>::act(arg7))));
+ new_thread (std::function<RT ()>
+ (std::bind(fun_ptr,
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4),
+ internal::maybe_make_ref<Arg5>::act(arg5),
+ internal::maybe_make_ref<Arg6>::act(arg6),
+ internal::maybe_make_ref<Arg7>::act(arg7))));
}
typename identity<Arg7>::type arg7)
{
return
- new_thread (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::ref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4),
-
internal::maybe_make_ref<Arg5>::act(arg5),
-
internal::maybe_make_ref<Arg6>::act(arg6),
-
internal::maybe_make_ref<Arg7>::act(arg7))));
+ new_thread (std::function<RT ()>
+ (std::bind(fun_ptr, std::ref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4),
+ internal::maybe_make_ref<Arg5>::act(arg5),
+ internal::maybe_make_ref<Arg6>::act(arg6),
+ internal::maybe_make_ref<Arg7>::act(arg7))));
}
#ifndef DEAL_II_CONST_MEMBER_DEDUCTION_BUG
typename identity<Arg7>::type arg7)
{
return
- new_thread (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::cref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4),
-
internal::maybe_make_ref<Arg5>::act(arg5),
-
internal::maybe_make_ref<Arg6>::act(arg6),
-
internal::maybe_make_ref<Arg7>::act(arg7))));
+ new_thread (std::function<RT ()>
+ (std::bind(fun_ptr, std::cref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4),
+ internal::maybe_make_ref<Arg5>::act(arg5),
+ internal::maybe_make_ref<Arg6>::act(arg6),
+ internal::maybe_make_ref<Arg7>::act(arg7))));
}
#endif
typename identity<Arg8>::type arg8)
{
return
- new_thread (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr,
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4),
-
internal::maybe_make_ref<Arg5>::act(arg5),
-
internal::maybe_make_ref<Arg6>::act(arg6),
-
internal::maybe_make_ref<Arg7>::act(arg7),
-
internal::maybe_make_ref<Arg8>::act(arg8))));
+ new_thread (std::function<RT ()>
+ (std::bind(fun_ptr,
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4),
+ internal::maybe_make_ref<Arg5>::act(arg5),
+ internal::maybe_make_ref<Arg6>::act(arg6),
+ internal::maybe_make_ref<Arg7>::act(arg7),
+ internal::maybe_make_ref<Arg8>::act(arg8))));
}
typename identity<Arg8>::type arg8)
{
return
- new_thread (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::ref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4),
-
internal::maybe_make_ref<Arg5>::act(arg5),
-
internal::maybe_make_ref<Arg6>::act(arg6),
-
internal::maybe_make_ref<Arg7>::act(arg7),
-
internal::maybe_make_ref<Arg8>::act(arg8))));
+ new_thread (std::function<RT ()>
+ (std::bind(fun_ptr, std::ref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4),
+ internal::maybe_make_ref<Arg5>::act(arg5),
+ internal::maybe_make_ref<Arg6>::act(arg6),
+ internal::maybe_make_ref<Arg7>::act(arg7),
+ internal::maybe_make_ref<Arg8>::act(arg8))));
}
#ifndef DEAL_II_CONST_MEMBER_DEDUCTION_BUG
typename identity<Arg8>::type arg8)
{
return
- new_thread (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::cref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4),
-
internal::maybe_make_ref<Arg5>::act(arg5),
-
internal::maybe_make_ref<Arg6>::act(arg6),
-
internal::maybe_make_ref<Arg7>::act(arg7),
-
internal::maybe_make_ref<Arg8>::act(arg8))));
+ new_thread (std::function<RT ()>
+ (std::bind(fun_ptr, std::cref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4),
+ internal::maybe_make_ref<Arg5>::act(arg5),
+ internal::maybe_make_ref<Arg6>::act(arg6),
+ internal::maybe_make_ref<Arg7>::act(arg7),
+ internal::maybe_make_ref<Arg8>::act(arg8))));
}
#endif
typename identity<Arg9>::type arg9)
{
return
- new_thread (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr,
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4),
-
internal::maybe_make_ref<Arg5>::act(arg5),
-
internal::maybe_make_ref<Arg6>::act(arg6),
-
internal::maybe_make_ref<Arg7>::act(arg7),
-
internal::maybe_make_ref<Arg8>::act(arg8),
-
internal::maybe_make_ref<Arg9>::act(arg9))));
+ new_thread (std::function<RT ()>
+ (std::bind(fun_ptr,
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4),
+ internal::maybe_make_ref<Arg5>::act(arg5),
+ internal::maybe_make_ref<Arg6>::act(arg6),
+ internal::maybe_make_ref<Arg7>::act(arg7),
+ internal::maybe_make_ref<Arg8>::act(arg8),
+ internal::maybe_make_ref<Arg9>::act(arg9))));
}
typename identity<Arg9>::type arg9)
{
return
- new_thread (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::ref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4),
-
internal::maybe_make_ref<Arg5>::act(arg5),
-
internal::maybe_make_ref<Arg6>::act(arg6),
-
internal::maybe_make_ref<Arg7>::act(arg7),
-
internal::maybe_make_ref<Arg8>::act(arg8),
-
internal::maybe_make_ref<Arg9>::act(arg9))));
+ new_thread (std::function<RT ()>
+ (std::bind(fun_ptr, std::ref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4),
+ internal::maybe_make_ref<Arg5>::act(arg5),
+ internal::maybe_make_ref<Arg6>::act(arg6),
+ internal::maybe_make_ref<Arg7>::act(arg7),
+ internal::maybe_make_ref<Arg8>::act(arg8),
+ internal::maybe_make_ref<Arg9>::act(arg9))));
}
#ifndef DEAL_II_CONST_MEMBER_DEDUCTION_BUG
typename identity<Arg9>::type arg9)
{
return
- new_thread (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::cref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4),
-
internal::maybe_make_ref<Arg5>::act(arg5),
-
internal::maybe_make_ref<Arg6>::act(arg6),
-
internal::maybe_make_ref<Arg7>::act(arg7),
-
internal::maybe_make_ref<Arg8>::act(arg8),
-
internal::maybe_make_ref<Arg9>::act(arg9))));
+ new_thread (std::function<RT ()>
+ (std::bind(fun_ptr, std::cref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4),
+ internal::maybe_make_ref<Arg5>::act(arg5),
+ internal::maybe_make_ref<Arg6>::act(arg6),
+ internal::maybe_make_ref<Arg7>::act(arg7),
+ internal::maybe_make_ref<Arg8>::act(arg8),
+ internal::maybe_make_ref<Arg9>::act(arg9))));
}
#endif
/**
* The function and its arguments that are to be run on the task.
*/
- std_cxx11::function<RT ()> function;
+ std::function<RT ()> function;
/**
* Variable holding the data the TBB needs to work with a task. Set by
/**
* Constructor. Take the function to be run on this task as argument.
*/
- TaskDescriptor (const std_cxx11::function<RT ()> &function);
+ TaskDescriptor (const std::function<RT ()> &function);
/**
* Default constructor. Throws an exception since we want to queue a
template <typename RT>
inline
- TaskDescriptor<RT>::TaskDescriptor (const std_cxx11::function<RT ()> &function)
+ TaskDescriptor<RT>::TaskDescriptor (const std::function<RT ()> &function)
:
function (function),
task(NULL),
* Constructor. Call the given function and emplace the return value
* into the slot reserved for this purpose.
*/
- TaskDescriptor (const std_cxx11::function<RT ()> &function)
+ TaskDescriptor (const std::function<RT ()> &function)
{
call (function, ret_val);
}
* @post Using this constructor automatically makes the task object
* joinable().
*/
- Task (const std_cxx11::function<RT ()> &function_object)
+ Task (const std::function<RT ()> &function_object)
{
// create a task descriptor and tell it to queue itself up with
// the scheduling system
bool joinable () const
{
return (task_descriptor !=
- std_cxx11::shared_ptr<internal::TaskDescriptor<RT> >());
+ std::shared_ptr<internal::TaskDescriptor<RT> >());
}
* pointer implementation will make sure that that object lives as long as
* there is at least one subscriber to it.
*/
- std_cxx11::shared_ptr<internal::TaskDescriptor<RT> > task_descriptor;
+ std::shared_ptr<internal::TaskDescriptor<RT> > task_descriptor;
};
/**
* Overload of the new_task function for objects that can be converted to
- * std_cxx11::function<RT ()>, i.e. anything that can be called like a
+ * std::function<RT ()>, i.e. anything that can be called like a
* function object without arguments and returning an object of type RT (or
* void).
*
template <typename RT>
inline
Task<RT>
- new_task (const std_cxx11::function<RT ()> &function)
+ new_task (const std::function<RT ()> &function)
{
return Task<RT>(function);
}
-> Task<decltype(function_object())>
{
typedef decltype(function_object()) return_type;
- return Task<return_type>(std_cxx11::function<return_type ()>(function_object));
+ return Task<return_type>(std::function<return_type ()>(function_object));
}
#endif
Task<RT>
new_task (RT (*fun_ptr)())
{
- return new_task (std_cxx11::function<RT ()>(fun_ptr));
+ return new_task (std::function<RT ()>(fun_ptr));
}
typename identity<C>::type &c)
{
return
- new_task (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::ref(c))));
+ new_task (std::function<RT ()>
+ (std::bind(fun_ptr, std::ref(c))));
}
#ifndef DEAL_II_CONST_MEMBER_DEDUCTION_BUG
const typename identity<C>::type &c)
{
return
- new_task (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::cref(c))));
+ new_task (std::function<RT ()>
+ (std::bind(fun_ptr, std::cref(c))));
}
#endif
typename identity<Arg1>::type arg1)
{
return
- new_task (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr,
-
internal::maybe_make_ref<Arg1>::act(arg1))));
+ new_task (std::function<RT ()>
+ (std::bind(fun_ptr,
+ internal::maybe_make_ref<Arg1>::act(arg1))));
}
typename identity<Arg1>::type arg1)
{
return
- new_task (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::ref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1))));
+ new_task (std::function<RT ()>
+ (std::bind(fun_ptr, std::ref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1))));
}
#ifndef DEAL_II_CONST_MEMBER_DEDUCTION_BUG
typename identity<Arg1>::type arg1)
{
return
- new_task (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::cref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1))));
+ new_task (std::function<RT ()>
+ (std::bind(fun_ptr, std::cref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1))));
}
#endif
typename identity<Arg2>::type arg2)
{
return
- new_task (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr,
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2))));
+ new_task (std::function<RT ()>
+ (std::bind(fun_ptr,
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2))));
}
typename identity<Arg2>::type arg2)
{
return
- new_task (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::ref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2))));
+ new_task (std::function<RT ()>
+ (std::bind(fun_ptr, std::ref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2))));
}
#ifndef DEAL_II_CONST_MEMBER_DEDUCTION_BUG
typename identity<Arg2>::type arg2)
{
return
- new_task (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::cref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2))));
+ new_task (std::function<RT ()>
+ (std::bind(fun_ptr, std::cref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2))));
}
#endif
typename identity<Arg3>::type arg3)
{
return
- new_task (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr,
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3))));
+ new_task (std::function<RT ()>
+ (std::bind(fun_ptr,
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3))));
}
typename identity<Arg3>::type arg3)
{
return
- new_task (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::ref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3))));
+ new_task (std::function<RT ()>
+ (std::bind(fun_ptr, std::ref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3))));
}
#ifndef DEAL_II_CONST_MEMBER_DEDUCTION_BUG
typename identity<Arg3>::type arg3)
{
return
- new_task (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::cref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3))));
+ new_task (std::function<RT ()>
+ (std::bind(fun_ptr, std::cref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3))));
}
#endif
typename identity<Arg4>::type arg4)
{
return
- new_task (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr,
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4))));
+ new_task (std::function<RT ()>
+ (std::bind(fun_ptr,
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4))));
}
typename identity<Arg4>::type arg4)
{
return
- new_task (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::ref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4))));
+ new_task (std::function<RT ()>
+ (std::bind(fun_ptr, std::ref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4))));
}
#ifndef DEAL_II_CONST_MEMBER_DEDUCTION_BUG
typename identity<Arg4>::type arg4)
{
return
- new_task (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::cref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4))));
+ new_task (std::function<RT ()>
+ (std::bind(fun_ptr, std::cref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4))));
}
#endif
typename identity<Arg5>::type arg5)
{
return
- new_task (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr,
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4),
-
internal::maybe_make_ref<Arg5>::act(arg5))));
+ new_task (std::function<RT ()>
+ (std::bind(fun_ptr,
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4),
+ internal::maybe_make_ref<Arg5>::act(arg5))));
}
typename identity<Arg5>::type arg5)
{
return
- new_task (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::ref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4),
-
internal::maybe_make_ref<Arg5>::act(arg5))));
+ new_task (std::function<RT ()>
+ (std::bind(fun_ptr, std::ref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4),
+ internal::maybe_make_ref<Arg5>::act(arg5))));
}
#ifndef DEAL_II_CONST_MEMBER_DEDUCTION_BUG
typename identity<Arg5>::type arg5)
{
return
- new_task (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::cref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4),
-
internal::maybe_make_ref<Arg5>::act(arg5))));
+ new_task (std::function<RT ()>
+ (std::bind(fun_ptr, std::cref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4),
+ internal::maybe_make_ref<Arg5>::act(arg5))));
}
#endif
typename identity<Arg6>::type arg6)
{
return
- new_task (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr,
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4),
-
internal::maybe_make_ref<Arg5>::act(arg5),
-
internal::maybe_make_ref<Arg6>::act(arg6))));
+ new_task (std::function<RT ()>
+ (std::bind(fun_ptr,
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4),
+ internal::maybe_make_ref<Arg5>::act(arg5),
+ internal::maybe_make_ref<Arg6>::act(arg6))));
}
typename identity<Arg6>::type arg6)
{
return
- new_task (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::ref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4),
-
internal::maybe_make_ref<Arg5>::act(arg5),
-
internal::maybe_make_ref<Arg6>::act(arg6))));
+ new_task (std::function<RT ()>
+ (std::bind(fun_ptr, std::ref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4),
+ internal::maybe_make_ref<Arg5>::act(arg5),
+ internal::maybe_make_ref<Arg6>::act(arg6))));
}
#ifndef DEAL_II_CONST_MEMBER_DEDUCTION_BUG
typename identity<Arg6>::type arg6)
{
return
- new_task (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::cref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4),
-
internal::maybe_make_ref<Arg5>::act(arg5),
-
internal::maybe_make_ref<Arg6>::act(arg6))));
+ new_task (std::function<RT ()>
+ (std::bind(fun_ptr, std::cref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4),
+ internal::maybe_make_ref<Arg5>::act(arg5),
+ internal::maybe_make_ref<Arg6>::act(arg6))));
}
#endif
typename identity<Arg7>::type arg7)
{
return
- new_task (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr,
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4),
-
internal::maybe_make_ref<Arg5>::act(arg5),
-
internal::maybe_make_ref<Arg6>::act(arg6),
-
internal::maybe_make_ref<Arg7>::act(arg7))));
+ new_task (std::function<RT ()>
+ (std::bind(fun_ptr,
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4),
+ internal::maybe_make_ref<Arg5>::act(arg5),
+ internal::maybe_make_ref<Arg6>::act(arg6),
+ internal::maybe_make_ref<Arg7>::act(arg7))));
}
typename identity<Arg7>::type arg7)
{
return
- new_task (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::ref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4),
-
internal::maybe_make_ref<Arg5>::act(arg5),
-
internal::maybe_make_ref<Arg6>::act(arg6),
-
internal::maybe_make_ref<Arg7>::act(arg7))));
+ new_task (std::function<RT ()>
+ (std::bind(fun_ptr, std::ref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4),
+ internal::maybe_make_ref<Arg5>::act(arg5),
+ internal::maybe_make_ref<Arg6>::act(arg6),
+ internal::maybe_make_ref<Arg7>::act(arg7))));
}
#ifndef DEAL_II_CONST_MEMBER_DEDUCTION_BUG
typename identity<Arg7>::type arg7)
{
return
- new_task (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::cref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4),
-
internal::maybe_make_ref<Arg5>::act(arg5),
-
internal::maybe_make_ref<Arg6>::act(arg6),
-
internal::maybe_make_ref<Arg7>::act(arg7))));
+ new_task (std::function<RT ()>
+ (std::bind(fun_ptr, std::cref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4),
+ internal::maybe_make_ref<Arg5>::act(arg5),
+ internal::maybe_make_ref<Arg6>::act(arg6),
+ internal::maybe_make_ref<Arg7>::act(arg7))));
}
#endif
typename identity<Arg8>::type arg8)
{
return
- new_task (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr,
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4),
-
internal::maybe_make_ref<Arg5>::act(arg5),
-
internal::maybe_make_ref<Arg6>::act(arg6),
-
internal::maybe_make_ref<Arg7>::act(arg7),
-
internal::maybe_make_ref<Arg8>::act(arg8))));
+ new_task (std::function<RT ()>
+ (std::bind(fun_ptr,
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4),
+ internal::maybe_make_ref<Arg5>::act(arg5),
+ internal::maybe_make_ref<Arg6>::act(arg6),
+ internal::maybe_make_ref<Arg7>::act(arg7),
+ internal::maybe_make_ref<Arg8>::act(arg8))));
}
typename identity<Arg8>::type arg8)
{
return
- new_task (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::ref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4),
-
internal::maybe_make_ref<Arg5>::act(arg5),
-
internal::maybe_make_ref<Arg6>::act(arg6),
-
internal::maybe_make_ref<Arg7>::act(arg7),
-
internal::maybe_make_ref<Arg8>::act(arg8))));
+ new_task (std::function<RT ()>
+ (std::bind(fun_ptr, std::ref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4),
+ internal::maybe_make_ref<Arg5>::act(arg5),
+ internal::maybe_make_ref<Arg6>::act(arg6),
+ internal::maybe_make_ref<Arg7>::act(arg7),
+ internal::maybe_make_ref<Arg8>::act(arg8))));
}
#ifndef DEAL_II_CONST_MEMBER_DEDUCTION_BUG
typename identity<Arg8>::type arg8)
{
return
- new_task (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::cref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4),
-
internal::maybe_make_ref<Arg5>::act(arg5),
-
internal::maybe_make_ref<Arg6>::act(arg6),
-
internal::maybe_make_ref<Arg7>::act(arg7),
-
internal::maybe_make_ref<Arg8>::act(arg8))));
+ new_task (std::function<RT ()>
+ (std::bind(fun_ptr, std::cref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4),
+ internal::maybe_make_ref<Arg5>::act(arg5),
+ internal::maybe_make_ref<Arg6>::act(arg6),
+ internal::maybe_make_ref<Arg7>::act(arg7),
+ internal::maybe_make_ref<Arg8>::act(arg8))));
}
#endif
typename identity<Arg9>::type arg9)
{
return
- new_task (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr,
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4),
-
internal::maybe_make_ref<Arg5>::act(arg5),
-
internal::maybe_make_ref<Arg6>::act(arg6),
-
internal::maybe_make_ref<Arg7>::act(arg7),
-
internal::maybe_make_ref<Arg8>::act(arg8),
-
internal::maybe_make_ref<Arg9>::act(arg9))));
+ new_task (std::function<RT ()>
+ (std::bind(fun_ptr,
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4),
+ internal::maybe_make_ref<Arg5>::act(arg5),
+ internal::maybe_make_ref<Arg6>::act(arg6),
+ internal::maybe_make_ref<Arg7>::act(arg7),
+ internal::maybe_make_ref<Arg8>::act(arg8),
+ internal::maybe_make_ref<Arg9>::act(arg9))));
}
typename identity<Arg9>::type arg9)
{
return
- new_task (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::ref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4),
-
internal::maybe_make_ref<Arg5>::act(arg5),
-
internal::maybe_make_ref<Arg6>::act(arg6),
-
internal::maybe_make_ref<Arg7>::act(arg7),
-
internal::maybe_make_ref<Arg8>::act(arg8),
-
internal::maybe_make_ref<Arg9>::act(arg9))));
+ new_task (std::function<RT ()>
+ (std::bind(fun_ptr, std::ref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4),
+ internal::maybe_make_ref<Arg5>::act(arg5),
+ internal::maybe_make_ref<Arg6>::act(arg6),
+ internal::maybe_make_ref<Arg7>::act(arg7),
+ internal::maybe_make_ref<Arg8>::act(arg8),
+ internal::maybe_make_ref<Arg9>::act(arg9))));
}
#ifndef DEAL_II_CONST_MEMBER_DEDUCTION_BUG
typename identity<Arg9>::type arg9)
{
return
- new_task (std_cxx11::function<RT ()>
- (std_cxx11::bind(fun_ptr, std_cxx11::cref(c),
-
internal::maybe_make_ref<Arg1>::act(arg1),
-
internal::maybe_make_ref<Arg2>::act(arg2),
-
internal::maybe_make_ref<Arg3>::act(arg3),
-
internal::maybe_make_ref<Arg4>::act(arg4),
-
internal::maybe_make_ref<Arg5>::act(arg5),
-
internal::maybe_make_ref<Arg6>::act(arg6),
-
internal::maybe_make_ref<Arg7>::act(arg7),
-
internal::maybe_make_ref<Arg8>::act(arg8),
-
internal::maybe_make_ref<Arg9>::act(arg9))));
+ new_task (std::function<RT ()>
+ (std::bind(fun_ptr, std::cref(c),
+ internal::maybe_make_ref<Arg1>::act(arg1),
+ internal::maybe_make_ref<Arg2>::act(arg2),
+ internal::maybe_make_ref<Arg3>::act(arg3),
+ internal::maybe_make_ref<Arg4>::act(arg4),
+ internal::maybe_make_ref<Arg5>::act(arg5),
+ internal::maybe_make_ref<Arg6>::act(arg6),
+ internal::maybe_make_ref<Arg7>::act(arg7),
+ internal::maybe_make_ref<Arg8>::act(arg8),
+ internal::maybe_make_ref<Arg9>::act(arg9))));
}
#endif
#include <deal.II/base/config.h>
#include <deal.II/base/signaling_nan.h>
-#include <deal.II/base/std_cxx11/function.h>
+#include <functional>
#include <vector>
DEAL_II_NAMESPACE_OPEN
* function returns the time at the end of the time step.
*/
virtual double evolve_one_time_step
- (std::vector<std_cxx11::function<VectorType (const double, const VectorType &)> > &F,
- std::vector<std_cxx11::function<VectorType (const double, const double, const VectorType &)> > &J_inverse,
- double t,
- double delta_t,
- VectorType &y) = 0;
+ (std::vector<std::function<VectorType (const double, const VectorType &)> > &F,
+ std::vector<std::function<VectorType (const double, const double, const VectorType &)> > &J_inverse,
+ double t,
+ double delta_t,
+ VectorType &y) = 0;
/**
* Empty structure used to store information.
* methods, @p F and @ J_inverse can only contain one element.
*/
double evolve_one_time_step
- (std::vector<std_cxx11::function<VectorType (const double, const VectorType &)> > &F,
- std::vector<std_cxx11::function<VectorType (const double, const double, const VectorType &)> > &J_inverse,
- double t,
- double delta_t,
- VectorType &y);
+ (std::vector<std::function<VectorType (const double, const VectorType &)> > &F,
+ std::vector<std::function<VectorType (const double, const double, const VectorType &)> > &J_inverse,
+ double t,
+ double delta_t,
+ VectorType &y);
/**
* Purely virtual function. This function is used to advance from time @p
* evolve_one_time_step returns the time at the end of the time step.
*/
virtual double evolve_one_time_step
- (std_cxx11::function<VectorType (const double, const VectorType &)> f,
- std_cxx11::function<VectorType (const double, const double, const VectorType &)> id_minus_tau_J_inverse,
- double t,
- double delta_t,
- VectorType &y) = 0;
+ (std::function<VectorType (const double, const VectorType &)> f,
+ std::function<VectorType (const double, const double, const VectorType &)> id_minus_tau_J_inverse,
+ double t,
+ double delta_t,
+ VectorType &y) = 0;
protected:
/**
* end of the time step.
*/
double evolve_one_time_step
- (std_cxx11::function<VectorType (const double, const VectorType &)> f,
- std_cxx11::function<VectorType (const double, const double, const VectorType &)> id_minus_tau_J_inverse,
- double t,
- double delta_t,
- VectorType &y);
+ (std::function<VectorType (const double, const VectorType &)> f,
+ std::function<VectorType (const double, const double, const VectorType &)> id_minus_tau_J_inverse,
+ double t,
+ double delta_t,
+ VectorType &y);
/**
* This function is used to advance from time @p t to t+ @p delta_t. This
* step.
*/
double evolve_one_time_step
- (std_cxx11::function<VectorType (const double, const VectorType &)> f,
- double t,
- double delta_t,
- VectorType &y);
+ (std::function<VectorType (const double, const VectorType &)> f,
+ double t,
+ double delta_t,
+ VectorType &y);
/**
* This structure stores the name of the method used.
* Compute the different stages needed.
*/
void compute_stages
- (std_cxx11::function<VectorType (const double, const VectorType &)> f,
- const double t,
- const double delta_t,
- const VectorType &y,
- std::vector<VectorType> &f_stages) const;
+ (std::function<VectorType (const double, const VectorType &)> f,
+ const double t,
+ const double delta_t,
+ const VectorType &y,
+ std::vector<VectorType> &f_stages) const;
/**
* Status structure of the object.
* returns the time at the end of the time step.
*/
double evolve_one_time_step
- (std_cxx11::function<VectorType (const double, const VectorType &)> f,
- std_cxx11::function<VectorType (const double, const double, const VectorType &)> id_minus_tau_J_inverse,
- double t,
- double delta_t,
- VectorType &y);
+ (std::function<VectorType (const double, const VectorType &)> f,
+ std::function<VectorType (const double, const double, const VectorType &)> id_minus_tau_J_inverse,
+ double t,
+ double delta_t,
+ VectorType &y);
/**
* Set the maximum number of iterations and the tolerance used by the
* Compute the different stages needed.
*/
void compute_stages
- (std_cxx11::function<VectorType (const double, const VectorType &)> f,
- std_cxx11::function<VectorType (const double, const double, const VectorType &)> id_minus_tau_J_inverse,
- double t,
- double delta_t,
- VectorType &y,
+ (std::function<VectorType (const double, const VectorType &)> f,
+ std::function<VectorType (const double, const double, const VectorType &)> id_minus_tau_J_inverse,
+ double t,
+ double delta_t,
+ VectorType &y,
std::vector<VectorType> &f_stages);
/**
* Newton solver used for the implicit stages.
*/
- void newton_solve(std_cxx11::function<void (const VectorType &,VectorType &)> get_residual,
- std_cxx11::function<VectorType (const VectorType &)> id_minus_tau_J_inverse,
- VectorType &y);
+ void newton_solve(std::function<void (const VectorType &,VectorType &)> get_residual,
+ std::function<VectorType (const VectorType &)> id_minus_tau_J_inverse,
+ VectorType &y);
/**
* Compute the residual needed by the Newton solver.
*/
- void compute_residual(std_cxx11::function<VectorType (const double, const VectorType &)> f,
- double t,
- double delta_t,
- const VectorType &old_y,
- const VectorType &y,
- VectorType &tendency,
- VectorType &residual) const;
+ void compute_residual(std::function<VectorType (const double, const VectorType &)> f,
+ double t,
+ double delta_t,
+ const VectorType &new_y,
+ const VectorType &y,
+ VectorType &tendency,
+ VectorType &residual) const;
/**
* When using SDIRK, there is no need to compute the linear combination of
* at the end of the time step.
*/
double evolve_one_time_step
- (std_cxx11::function<VectorType (const double, const VectorType &)> f,
- std_cxx11::function<VectorType (const double, const double, const VectorType &)> id_minus_tau_J_inverse,
- double t,
- double delta_t,
+ (std::function<VectorType (const double, const VectorType &)> f,
+ std::function<VectorType (const double, const double, const VectorType &)> id_minus_tau_J_inverse,
+ double t,
+ double delta_t,
VectorType &y);
/**
* step.
*/
double evolve_one_time_step
- (std_cxx11::function<VectorType (const double, const VectorType &)> f,
- double t,
- double delta_t,
+ (std::function<VectorType (const double, const VectorType &)> f,
+ double t,
+ double delta_t,
VectorType &y);
/**
/**
* Compute the different stages needed.
*/
- void compute_stages(std_cxx11::function<VectorType (const double, const VectorType &)> f,
- const double t,
- const double delta_t,
- const VectorType &y,
- std::vector<VectorType> &f_stages);
+ void compute_stages(std::function<VectorType (const double, const VectorType &)> f,
+ const double t,
+ const double delta_t,
+ const VectorType &y,
+ std::vector<VectorType> &f_stages);
/**
* This parameter is the factor (>1) by which the time step is multiplied
#ifndef dealii__time_stepping_templates_h
#define dealii__time_stepping_templates_h
-#include <deal.II/base/std_cxx11/bind.h>
#include <deal.II/base/exceptions.h>
#include <deal.II/base/time_stepping.h>
+#include <functional>
+
DEAL_II_NAMESPACE_OPEN
namespace TimeStepping
template <typename VectorType>
double RungeKutta<VectorType>::evolve_one_time_step(
- std::vector<std_cxx11::function<VectorType (const double, const VectorType &)> > &F,
- std::vector<std_cxx11::function<VectorType (const double, const double, const VectorType &)> > &J_inverse,
+ std::vector<std::function<VectorType (const double, const VectorType &)> > &F,
+ std::vector<std::function<VectorType (const double, const double, const VectorType &)> > &J_inverse,
double t,
double delta_t,
template <typename VectorType>
double ExplicitRungeKutta<VectorType>::evolve_one_time_step
- (std_cxx11::function<VectorType (const double, const VectorType &)> f,
- std_cxx11::function<VectorType (const double, const double, const VectorType &)> /*id_minus_tau_J_inverse*/,
+ (std::function<VectorType (const double, const VectorType &)> f,
+ std::function<VectorType (const double, const double, const VectorType &)> /*id_minus_tau_J_inverse*/,
double t,
double delta_t,
VectorType &y)
template <typename VectorType>
double ExplicitRungeKutta<VectorType>::evolve_one_time_step
- (std_cxx11::function<VectorType (const double, const VectorType &)> f,
+ (std::function<VectorType (const double, const VectorType &)> f,
double t,
double delta_t,
VectorType &y)
template <typename VectorType>
void ExplicitRungeKutta<VectorType>::compute_stages
- (std_cxx11::function<VectorType (const double, const VectorType &)> f,
+ (std::function<VectorType (const double, const VectorType &)> f,
const double t,
const double delta_t,
const VectorType &y,
template <typename VectorType>
double ImplicitRungeKutta<VectorType>::evolve_one_time_step
- (std_cxx11::function<VectorType (const double, const VectorType &)> f,
- std_cxx11::function<VectorType (const double, const double, const VectorType &)> id_minus_tau_J_inverse,
+ (std::function<VectorType (const double, const VectorType &)> f,
+ std::function<VectorType (const double, const double, const VectorType &)> id_minus_tau_J_inverse,
double t,
double delta_t,
VectorType &y)
template <typename VectorType>
void ImplicitRungeKutta<VectorType>::compute_stages(
- std_cxx11::function<VectorType (const double, const VectorType &)> f,
- std_cxx11::function<VectorType (const double, const double, const VectorType &)> id_minus_tau_J_inverse,
+ std::function<VectorType (const double, const VectorType &)> f,
+ std::function<VectorType (const double, const double, const VectorType &)> id_minus_tau_J_inverse,
double t,
double delta_t,
VectorType &y,
// Solve the nonlinear system using Newton's method
const double new_t = t+this->c[i]*delta_t;
const double new_delta_t = this->a[i][i]*delta_t;
- newton_solve(std_cxx11::bind(&ImplicitRungeKutta<VectorType>::compute_residual,this,f,new_t,new_delta_t,
- std_cxx11::cref(old_y),std_cxx11::_1,std_cxx11::ref(f_stages[i]),std_cxx11::_2),
- std_cxx11::bind(id_minus_tau_J_inverse,new_t,new_delta_t,std_cxx11::_1),y);
+ newton_solve(std::bind(&ImplicitRungeKutta<VectorType>::compute_residual,this,f,new_t,new_delta_t,
+ std::cref(old_y),std::placeholders::_1,std::ref(f_stages[i]),std::placeholders::_2),
+ std::bind(id_minus_tau_J_inverse,new_t,new_delta_t,std::placeholders::_1),y);
}
}
template <typename VectorType>
void ImplicitRungeKutta<VectorType>::newton_solve(
- std_cxx11::function<void (const VectorType &,VectorType &)> get_residual,
- std_cxx11::function<VectorType (const VectorType &)> id_minus_tau_J_inverse,
+ std::function<void (const VectorType &,VectorType &)> get_residual,
+ std::function<VectorType (const VectorType &)> id_minus_tau_J_inverse,
VectorType &y)
{
VectorType residual(y);
template <typename VectorType>
void ImplicitRungeKutta<VectorType>::compute_residual
- (std_cxx11::function<VectorType (const double, const VectorType &)> f,
+ (std::function<VectorType (const double, const VectorType &)> f,
double t,
double delta_t,
const VectorType &old_y,
template <typename VectorType>
double EmbeddedExplicitRungeKutta<VectorType>::evolve_one_time_step(
- std_cxx11::function<VectorType (const double, const VectorType &)> f,
- std_cxx11::function<VectorType (const double, const double, const VectorType &)> /*id_minus_tau_J_inverse*/,
+ std::function<VectorType (const double, const VectorType &)> f,
+ std::function<VectorType (const double, const double, const VectorType &)> /*id_minus_tau_J_inverse*/,
double t,
double delta_t,
VectorType &y)
template <typename VectorType>
double EmbeddedExplicitRungeKutta<VectorType>::evolve_one_time_step(
- std_cxx11::function<VectorType (const double, const VectorType &)> f,
+ std::function<VectorType (const double, const VectorType &)> f,
double t, double delta_t, VectorType &y)
{
bool done = false;
template <typename VectorType>
void EmbeddedExplicitRungeKutta<VectorType>::compute_stages(
- std_cxx11::function<VectorType (const double, const VectorType &)> f,
+ std::function<VectorType (const double, const VectorType &)> f,
const double t,
const double delta_t,
const VectorType &y,
#include <deal.II/base/multithread_info.h>
#include <deal.II/base/thread_management.h>
#include <deal.II/base/template_constraints.h>
-#include <deal.II/base/std_cxx11/function.h>
-#include <deal.II/base/std_cxx11/bind.h>
#include <deal.II/base/thread_local_storage.h>
#include <deal.II/base/parallel.h>
#include <vector>
#include <utility>
#include <memory>
-
+#include <functional>
DEAL_II_NAMESPACE_OPEN
namespace internal
{
-//TODO: The following classes all use std_cxx11::shared_ptr, but the
+//TODO: The following classes all use std::shared_ptr, but the
// correct pointer class would actually be std::unique_ptr. make this
// replacement whenever we have a class that provides these semantics
// and that is available also as a fall-back whenever via boost or similar
*/
struct ScratchDataObject
{
- std_cxx11::shared_ptr<ScratchData> scratch_data;
- bool currently_in_use;
+ std::shared_ptr<ScratchData> scratch_data;
+ bool currently_in_use;
/**
* Default constructor.
* operate as well as a pointer to the function that will do the
* assembly.
*/
- Worker (const std_cxx11::function<void (const Iterator &,
- ScratchData &,
- CopyData &)> &worker,
+ Worker (const std::function<void (const Iterator &,
+ ScratchData &,
+ CopyData &)> &worker,
bool copier_exist=true)
:
tbb::filter (/* is_serial= */ false),
* Pointer to the function that does the assembling on the sequence of
* cells.
*/
- const std_cxx11::function<void (const Iterator &,
- ScratchData &,
- CopyData &)> worker;
+ const std::function<void (const Iterator &,
+ ScratchData &,
+ CopyData &)> worker;
/**
* This flag is true if the copier stage exist. If it does not, the
* copying from the additional data object to the global matrix or
* similar.
*/
- Copier (const std_cxx11::function<void (const CopyData &)> &copier)
+ Copier (const std::function<void (const CopyData &)> &copier)
:
tbb::filter (/*is_serial=*/true),
copier (copier)
/**
* Pointer to the function that does the copying of data.
*/
- const std_cxx11::function<void (const CopyData &)> copier;
+ const std::function<void (const CopyData &)> copier;
};
}
typename CopyData>
struct ScratchAndCopyDataObjects
{
- std_cxx11::shared_ptr<ScratchData> scratch_data;
- std_cxx11::shared_ptr<CopyData> copy_data;
- bool currently_in_use;
+ std::shared_ptr<ScratchData> scratch_data;
+ std::shared_ptr<CopyData> copy_data;
+ bool currently_in_use;
/**
* Default constructor.
/**
* Constructor.
*/
- WorkerAndCopier (const std_cxx11::function<void (const Iterator &,
- ScratchData &,
- CopyData &)> &worker,
- const std_cxx11::function<void (const CopyData &)> &copier,
+ WorkerAndCopier (const std::function<void (const Iterator &,
+ ScratchData &,
+ CopyData &)> &worker,
+ const std::function<void (const CopyData &)> &copier,
const ScratchData &sample_scratch_data,
const CopyData &sample_copy_data)
:
* Pointer to the function that does the assembling on the sequence of
* cells.
*/
- const std_cxx11::function<void (const Iterator &,
- ScratchData &,
- CopyData &)> worker;
+ const std::function<void (const Iterator &,
+ ScratchData &,
+ CopyData &)> worker;
/**
* Pointer to the function that does the copying from local
* contribution to global object.
*/
- const std_cxx11::function<void (const CopyData &)> copier;
+ const std::function<void (const CopyData &)> copier;
/**
* References to sample scratch and copy data for when we need them.
{
// need to check if the function is not the zero function. To
// check zero-ness, create a C++ function out of it and check that
- if (static_cast<const std_cxx11::function<void (const Iterator &,
- ScratchData &,
- CopyData &)>& >(worker))
+ if (static_cast<const std::function<void (const Iterator &,
+ ScratchData &,
+ CopyData &)>& >(worker))
worker (i, scratch_data, copy_data);
- if (static_cast<const std_cxx11::function<void (const CopyData &)>& >
+ if (static_cast<const std::function<void (const CopyData &)>& >
(copier))
copier (copy_data);
}
else // have TBB and use more than one thread
{
// Check that the copier exist
- if (static_cast<const std_cxx11::function<void (const CopyData &)>& >(copier))
+ if (static_cast<const std::function<void (const CopyData &)>& >(copier))
{
// create the three stages of the pipeline
internal::Implementation2::IteratorRangeToItemStream<Iterator,ScratchData,CopyData>
{
// need to check if the function is not the zero function. To
// check zero-ness, create a C++ function out of it and check that
- if (static_cast<const std_cxx11::function<void (const Iterator &,
- ScratchData &,
- CopyData &)>& >(worker))
+ if (static_cast<const std::function<void (const Iterator &,
+ ScratchData &,
+ CopyData &)>& >(worker))
worker (*p, scratch_data, copy_data);
- if (static_cast<const std_cxx11::function<void (const CopyData &)>& >(copier))
+ if (static_cast<const std::function<void (const CopyData &)>& >(copier))
copier (copy_data);
}
}
(colored_iterators[color].begin(),
colored_iterators[color].end(),
/*grain_size=*/chunk_size),
- std_cxx11::bind (&WorkerAndCopier::operator(),
- std_cxx11::ref(worker_and_copier),
- std_cxx11::_1),
+ std::bind (&WorkerAndCopier::operator(),
+ std::ref(worker_and_copier),
+ std::placeholders::_1),
tbb::auto_partitioner());
}
}
{
// forward to the other function
run (begin, end,
- std_cxx11::bind (worker,
- std_cxx11::ref (main_object),
- std_cxx11::_1, std_cxx11::_2, std_cxx11::_3),
- std_cxx11::bind (copier,
- std_cxx11::ref (main_object),
- std_cxx11::_1),
+ std::bind (worker,
+ std::ref (main_object),
+ std::placeholders::_1, std::placeholders::_2, std::placeholders::_3),
+ std::bind (copier,
+ std::ref (main_object),
+ std::placeholders::_1),
sample_scratch_data,
sample_copy_data,
queue_length,
#include <deal.II/distributed/tria_base.h>
-#include <deal.II/base/std_cxx1x/function.h>
-#include <deal.II/base/std_cxx1x/tuple.h>
+#include <tuple>
+#include <functional>
#include <set>
#include <vector>
#include <list>
#include <deal.II/base/template_constraints.h>
#include <deal.II/grid/tria.h>
-#include <deal.II/base/std_cxx11/function.h>
-#include <deal.II/base/std_cxx11/tuple.h>
-
#include <deal.II/distributed/tria_base.h>
#include <deal.II/distributed/p4est_wrappers.h>
#include <vector>
#include <list>
#include <utility>
+#include <functional>
+#include <tuple>
#ifdef DEAL_II_WITH_MPI
# include <mpi.h>
* information into the function. C++ provides a nice mechanism for this
* that is best explained using an example:
* @code
- * #include <deal.II/base/std_cxx11/bind.h>
+ * #include <functional>
*
* template <int dim>
* void set_boundary_ids (parallel::distributed::Triangulation<dim> &triangulation)
* ... create the coarse mesh ...
*
* coarse_grid.signals.post_refinement.connect
- * (std_cxx11::bind (&set_boundary_ids<dim>,
- * std_cxx11::ref(coarse_grid)));
+ * (std::bind (&set_boundary_ids<dim>,
+ * std::ref(coarse_grid)));
*
* }
* @endcode
*
- * What the call to <code>std_cxx11::bind</code> does is to produce an
+ * What the call to <code>std::bind</code> does is to produce an
* object that can be called like a function with no arguments. It does so
* by taking the address of a function that does, in fact, take an
* argument but permanently fix this one argument to a reference to the
* static, but possibly private) member function of the
* <code>MyClass</code> class, then the following will work:
* @code
- * #include <deal.II/base/std_cxx11/bind.h>
+ * #include <functional>
*
* template <int dim>
* void
* ... create the coarse mesh ...
*
* coarse_grid.signals.post_refinement.connect
- * (std_cxx11::bind (&MyGeometry<dim>::set_boundary_ids,
- * std_cxx11::cref(*this),
- * std_cxx11::ref(coarse_grid)));
+ * (std::bind (&MyGeometry<dim>::set_boundary_ids,
+ * std::cref(*this),
+ * std::ref(coarse_grid)));
* }
* @endcode
* Here, like any other member function, <code>set_boundary_ids</code>
*/
unsigned int
register_data_attach (const std::size_t size,
- const std_cxx11::function<void (const cell_iterator &,
- const CellStatus,
- void *)> &pack_callback);
+ const std::function<void (const cell_iterator &,
+ const CellStatus,
+ void *)> &pack_callback);
/**
* The supplied callback function is called for each newly locally owned
*/
void
notify_ready_to_unpack (const unsigned int offset,
- const std_cxx11::function<void (const cell_iterator &,
- const CellStatus,
- const void *)> &unpack_callback);
+ const std::function<void (const cell_iterator &,
+ const CellStatus,
+ const void *)> &unpack_callback);
/**
* Return a permutation vector for the order the coarse cells are handed
*/
unsigned int n_attached_deserialize;
- typedef std_cxx11::function<
+ typedef std::function<
void(typename Triangulation<dim,spacedim>::cell_iterator, CellStatus, void *)
> pack_callback_t;
#include <deal.II/base/mpi.h>
#include <deal.II/grid/tria.h>
-#include <deal.II/base/std_cxx1x/function.h>
-#include <deal.II/base/std_cxx1x/tuple.h>
-
+#include <functional>
+#include <tuple>
#include <set>
#include <vector>
#include <list>
#include <deal.II/base/smartpointer.h>
#include <deal.II/base/index_set.h>
#include <deal.II/base/iterator_range.h>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
#include <deal.II/dofs/block_info.h>
#include <deal.II/dofs/dof_iterator_selector.h>
#include <deal.II/dofs/number_cache.h>
#include <vector>
#include <map>
#include <set>
+#include <memory>
DEAL_II_NAMESPACE_OPEN
* An object that describes how degrees of freedom should be distributed and
* renumbered.
*/
- std_cxx11::shared_ptr<dealii::internal::DoFHandler::Policy::PolicyBase<dim,spacedim> > policy;
+ std::shared_ptr<dealii::internal::DoFHandler::Policy::PolicyBase<dim,spacedim> > policy;
/**
* A structure that contains all sorts of numbers that characterize the
* Return the coefficients of 4 local linear shape functions $\phi_j(x,y) = a x + b y + c$ on given cell.
* For each local shape function, the array consists of three coefficients is in order of a,b and c.
*/
- static std_cxx11::array<std_cxx11::array<double,3>,4>
+ static std::array<std::array<double,3>,4>
get_linear_shape_coefficients (const Triangulation<2,2>::cell_iterator &cell);
/**
-#include <deal.II/base/std_cxx11/shared_ptr.h>
#include <deal.II/base/config.h>
#include <deal.II/base/subscriptor.h>
#include <deal.II/base/exceptions.h>
#include <vector>
#include <string>
+#include <memory>
DEAL_II_NAMESPACE_OPEN
template <int dim, typename T>
std::pair<std::vector<unsigned int>,std::vector<double> >
process_coefficients(const Table<dim,T> &coefficients,
- const std_cxx11::function<std::pair<bool,unsigned int>(const TableIndices<dim> &)> &predicate,
+ const std::function<std::pair<bool,unsigned int>(const TableIndices<dim> &)> &predicate,
const VectorTools::NormType norm);
template <int dim,typename T>
void fill_map_index(const Table<dim,T> &coefficients,
const TableIndices<dim> &ind,
- const std_cxx11::function<std::pair<bool,unsigned int>(const TableIndices<dim> &)> &predicate,
+ const std::function<std::pair<bool,unsigned int>(const TableIndices<dim> &)> &predicate,
std::map<unsigned int, std::vector<T> > &pred_to_values)
{
const std::pair<bool,unsigned int> pred_pair = predicate(ind);
template <typename T>
void fill_map(const Table<1,T> &coefficients,
- const std_cxx11::function<std::pair<bool,unsigned int>(const TableIndices<1> &)> &predicate,
+ const std::function<std::pair<bool,unsigned int>(const TableIndices<1> &)> &predicate,
std::map<unsigned int, std::vector<T> > &pred_to_values)
{
for (unsigned int i = 0; i < coefficients.size(0); i++)
template <typename T>
void fill_map(const Table<2,T> &coefficients,
- const std_cxx11::function<std::pair<bool,unsigned int>(const TableIndices<2> &)> &predicate,
+ const std::function<std::pair<bool,unsigned int>(const TableIndices<2> &)> &predicate,
std::map<unsigned int, std::vector<T> > &pred_to_values)
{
for (unsigned int i = 0; i < coefficients.size(0); i++)
template <typename T>
void fill_map(const Table<3,T> &coefficients,
- const std_cxx11::function<std::pair<bool,unsigned int>(const TableIndices<3> &)> &predicate,
+ const std::function<std::pair<bool,unsigned int>(const TableIndices<3> &)> &predicate,
std::map<unsigned int, std::vector<T> > &pred_to_values)
{
for (unsigned int i = 0; i < coefficients.size(0); i++)
template <int dim, typename T>
std::pair<std::vector<unsigned int>,std::vector<double> >
FESeries::process_coefficients(const Table<dim,T> &coefficients,
- const std_cxx11::function<std::pair<bool,unsigned int>(const TableIndices<dim> &)> &predicate,
+ const std::function<std::pair<bool,unsigned int>(const TableIndices<dim> &)> &predicate,
const VectorTools::NormType norm)
{
std::vector<unsigned int> predicate_values;
* pointers to the underlying base finite elements. The last one of these
* copies around will then delete the pointer to the base elements.
*/
- std::vector<std::pair<std_cxx11::shared_ptr<const FiniteElement<dim,spacedim> >,
+ std::vector<std::pair<std::shared_ptr<const FiniteElement<dim,spacedim> >,
unsigned int> >
base_elements;
#include <deal.II/base/vector_slice.h>
#include <deal.II/base/quadrature.h>
#include <deal.II/base/table.h>
-#include <deal.II/base/std_cxx11/unique_ptr.h>
#include <deal.II/grid/tria.h>
#include <deal.II/grid/tria_iterator.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/fe/mapping.h>
#include <algorithm>
+#include <memory>
// dummy include in order to have the
// definition of PetscScalar available
* is necessary for the <tt>get_function_*</tt> functions as well as the
* functions of same name in the extractor classes.
*/
- std_cxx11::unique_ptr<const CellIteratorBase> present_cell;
+ std::unique_ptr<const CellIteratorBase> present_cell;
/**
* A signal connection we use to ensure we get informed whenever the
* Mapping::get_data(), Mapping::get_face_data(), or
* Mapping::get_subface_data().
*/
- std_cxx11::unique_ptr<typename Mapping<dim,spacedim>::InternalDataBase> mapping_data;
+ std::unique_ptr<typename Mapping<dim,spacedim>::InternalDataBase> mapping_data;
/**
* An object into which the Mapping::fill_fe_values() and similar functions
* FiniteElement::get_data(), Mapping::get_face_data(), or
* FiniteElement::get_subface_data().
*/
- std_cxx11::unique_ptr<typename FiniteElement<dim,spacedim>::InternalDataBase> fe_data;
+ std::unique_ptr<typename FiniteElement<dim,spacedim>::InternalDataBase> fe_data;
/**
* An object into which the FiniteElement::fill_fe_values() and similar
#include <deal.II/base/config.h>
#include <deal.II/base/derivative_form.h>
-#include <deal.II/base/std_cxx11/array.h>
#include <deal.II/base/array_view.h>
#include <deal.II/grid/tria.h>
#include <deal.II/fe/fe_update_flags.h>
+#include <array>
#include <cmath>
DEAL_II_NAMESPACE_OPEN
* <code>cell-@>vertex(v)</code>.
*/
virtual
- std
_cxx11::array<Point<spacedim>, GeometryInfo<dim>::vertices_per_cell>
+ std::array<Point<spacedim>, GeometryInfo<dim>::vertices_per_cell>
get_vertices (const typename Triangulation<dim,spacedim>::cell_iterator &cell) const;
/**
#include <deal.II/fe/mapping.h>
#include <deal.II/fe/fe.h>
-#include <deal.II/base/std_cxx11/array.h>
+#include <array>
DEAL_II_NAMESPACE_OPEN
*
* Filled once.
*/
- std_cxx11::array<std::vector<Tensor<1,dim> >, GeometryInfo<dim>::faces_per_cell *(dim-1)> unit_tangentials;
+ std::array<std::vector<Tensor<1,dim> >, GeometryInfo<dim>::faces_per_cell *(dim-1)> unit_tangentials;
/**
* Number of shape functions. If this is a Q1 mapping, then it is simply
*
* Filled once.
*/
- std_cxx11::array<std::vector<Tensor<1,dim> >, GeometryInfo<dim>::faces_per_cell *(dim-1)> unit_tangentials;
+ std::array<std::vector<Tensor<1,dim> >, GeometryInfo<dim>::faces_per_cell *(dim-1)> unit_tangentials;
/**
* Tensors of covariant transformation at each of the quadrature points.
* A pointer to a structure to store the information for the pure $Q_1$
* mapping that is, by default, used on all interior cells.
*/
- std_cxx11::unique_ptr<typename MappingQGeneric<dim,spacedim>::InternalData> mapping_q1_data;
+ std::unique_ptr<typename MappingQGeneric<dim,spacedim>::InternalData> mapping_q1_data;
/**
* A pointer to a structure to store the information for the full $Q_p$
* mapping that is, by default, used on all boundary cells.
*/
- std_cxx11::unique_ptr<typename MappingQGeneric<dim,spacedim>::InternalData> mapping_qp_data;
+ std::unique_ptr<typename MappingQGeneric<dim,spacedim>::InternalData> mapping_qp_data;
};
protected:
* the qp_mapping and q1_mapping variables point to the same underlying
* object.
*/
- std_cxx11::shared_ptr<const MappingQGeneric<dim,spacedim> > q1_mapping;
+ std::shared_ptr<const MappingQGeneric<dim,spacedim> > q1_mapping;
/**
* Pointer to a Q_p mapping. This mapping is used on boundary cells unless
* the qp_mapping and q1_mapping variables point to the same underlying
* object.
*/
- std_cxx11::shared_ptr<const MappingQGeneric<dim,spacedim> > qp_mapping;
+ std::shared_ptr<const MappingQGeneric<dim,spacedim> > qp_mapping;
};
/*@}*/
#define dealii__mapping_q1_eulerian_h
#include <deal.II/base/config.h>
-#include <deal.II/base/std_cxx11/array.h>
#include <deal.II/base/smartpointer.h>
#include <deal.II/fe/mapping_q1.h>
#include <deal.II/dofs/dof_handler.h>
+
+#include <array>
+
DEAL_II_NAMESPACE_OPEN
template <typename> class Vector;
* addition to the geometry of the cell.
*/
virtual
- std
_cxx11::array<Point<spacedim>, GeometryInfo<dim>::vertices_per_cell>
+ std::array<Point<spacedim>, GeometryInfo<dim>::vertices_per_cell>
get_vertices (const typename Triangulation<dim,spacedim>::cell_iterator &cell) const;
/**
* addition to the geometry of the cell.
*/
virtual
- std
_cxx11::array<Point<spacedim>, GeometryInfo<dim>::vertices_per_cell>
+ std::array<Point<spacedim>, GeometryInfo<dim>::vertices_per_cell>
get_vertices (const typename Triangulation<dim,spacedim>::cell_iterator &cell) const;
/**
* field in addition to the geometry of the cell.
*/
virtual
- std
_cxx11::array<Point<spacedim>, GeometryInfo<dim>::vertices_per_cell>
+ std::array<Point<spacedim>, GeometryInfo<dim>::vertices_per_cell>
get_vertices (const typename Triangulation<dim,spacedim>::cell_iterator &cell) const;
/**
#include <deal.II/fe/mapping.h>
#include <deal.II/fe/fe_q.h>
-#include <deal.II/base/std_cxx11/array.h>
-
+#include <array>
#include <cmath>
DEAL_II_NAMESPACE_OPEN
*
* Filled once.
*/
- std_cxx11::array<std::vector<Tensor<1,dim> >, GeometryInfo<dim>::faces_per_cell *(dim-1)> unit_tangentials;
+ std::array<std::vector<Tensor<1,dim> >, GeometryInfo<dim>::faces_per_cell *(dim-1)> unit_tangentials;
/**
* The polynomial degree of the mapping. Since the objects here are also
* shape functions/DoFs on non-standard faces. This is used to reorder
* support points in the same way.
*/
- const std_cxx11::unique_ptr<FE_Q<dim> > fe_q;
+ const std::unique_ptr<FE_Q<dim> > fe_q;
/**
* A vector of tables of weights by which we multiply the locations of the
#include <deal.II/base/config.h>
#include <deal.II/base/exceptions.h>
-#include <deal.II/base/std_cxx11/array.h>
+#include <array>
#include <vector>
#include <iostream>
* (using 2 times 32 bit for storage), a limitation that is identical to
* the one used by p4est.
*/
- typedef std_cxx11::array<unsigned int, 4> binary_type;
+ typedef std::array<unsigned int, 4> binary_type;
/**
* Construct a CellId object with a given @p coarse_cell_id and vector of
* the array can be extended.
*/
#ifdef DEAL_II_WITH_P4EST
- std_cxx11::array<char,internal::p4est::functions<2>::max_level> child_indices;
+ std::array<char,internal::p4est::functions<2>::max_level> child_indices;
#else
- std_cxx11::array<char,30> child_indices;
+ std::array<char,30> child_indices;
#endif
friend std::istream &operator>> (std::istream &is, CellId &cid);
* @endcode
* then
* @code
- * std_cxx11::bind (&level_equal_to<active_cell_iterator>, std_cxx11::_1, 3)
+ * std::bind (&level_equal_to<active_cell_iterator>, std::placeholders::_1, 3)
* @endcode
* is another valid predicate (here: a function that returns true if either
* the iterator is past the end or the level is equal to the second argument;
#include <deal.II/base/config.h>
-#include <deal.II/base/std_cxx11/array.h>
#include <deal.II/base/exceptions.h>
#include <deal.II/base/point.h>
#include <deal.II/base/table.h>
#include <deal.II/base/function.h>
#include <deal.II/grid/tria.h>
+
+#include <array>
#include <map>
DEAL_II_NAMESPACE_OPEN
void
subdivided_parallelepiped (Triangulation<dim, spacedim> &tria,
const Point<spacedim> &origin,
- const std_cxx11::array<Tensor<1,spacedim>,dim> &edges,
+ const std::array<Tensor<1,spacedim>,dim> &edges,
const std::vector<unsigned int> &subdivisions = std::vector<unsigned int>(),
const bool colorize = false);
std::vector<typename MeshType::active_cell_iterator>
compute_active_cell_halo_layer
(const MeshType &mesh,
- const std_cxx11::function<bool (const typename MeshType::active_cell_iterator &)> &predicate);
+ const std::function<bool (const typename MeshType::active_cell_iterator &)> &predicate);
/**
* Extract and return ghost cells which are the active cell layer around all
#include <deal.II/base/smartpointer.h>
#include <deal.II/base/geometry_info.h>
#include <deal.II/base/iterator_range.h>
-#include <deal.II/base/std_cxx11/function.h>
-#include <deal.II/base/std_cxx11/unique_ptr.h>
#include <deal.II/grid/tria_iterator_selector.h>
// Ignore deprecation warnings for auto_ptr.
#include <map>
#include <numeric>
#include <bitset>
+#include <functional>
+#include <memory>
DEAL_II_NAMESPACE_OPEN
* // mesh refinement
* previous_cell = current_cell;
* previous_cell->get_triangulation().signals.post_refinement
- * .connect (std_cxx11::bind (&FEValues<dim>::invalidate_previous_cell,
- * std_cxx11::ref (*this)));
+ * .connect (std::bind (&FEValues<dim>::invalidate_previous_cell,
+ * std::ref (*this)));
* }
* else
* previous_cell = current_cell;
* in 2D it contains data concerning lines and in 3D quads and lines. All
* of these have no level and are therefore treated separately.
*/
- std_cxx11::unique_ptr<dealii::internal::Triangulation::TriaFaces<dim> > faces;
+ std::unique_ptr<dealii::internal::Triangulation::TriaFaces<dim> > faces;
/**
* this field (that can be modified by TriaAccessor::set_boundary_id) were
* not a pointer.
*/
- std_cxx11::unique_ptr<std::map<unsigned int, types::boundary_id> > vertex_to_boundary_id_map_1d;
+ std::unique_ptr<std::map<unsigned int, types::boundary_id> > vertex_to_boundary_id_map_1d;
/**
* this field (that can be modified by TriaAccessor::set_boundary_id) were
* not a pointer.
*/
- std_cxx11::unique_ptr<std::map<unsigned int, types::manifold_id> > vertex_to_manifold_id_map_1d;
+ std::unique_ptr<std::map<unsigned int, types::manifold_id> > vertex_to_manifold_id_map_1d;
// make a couple of classes friends
template <int,int,int> friend class TriaAccessorBase;
/**
* Point generator for the intermediate points on a boundary.
*/
- mutable std::vector<std_cxx11::shared_ptr<QGaussLobatto<1> > > points;
+ mutable std::vector<std::shared_ptr<QGaussLobatto<1> > > points;
/**
* Mutex for protecting the points array.
#define dealii__fe_collection_h
#include <deal.II/base/config.h>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
#include <deal.II/fe/fe.h>
#include <deal.II/fe/fe_values_extractors.h>
#include <deal.II/fe/component_mask.h>
+#include <memory>
+
DEAL_II_NAMESPACE_OPEN
namespace hp
/**
* Array of pointers to the finite elements stored by this collection.
*/
- std::vector<std_cxx11::shared_ptr<const FiniteElement<dim,spacedim> > > finite_elements;
+ std::vector<std::shared_ptr<const FiniteElement<dim,spacedim> > > finite_elements;
};
#include <deal.II/fe/fe_values.h>
#include <map>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
+#include <memory>
DEAL_II_NAMESPACE_OPEN
* Initially, all entries have zero pointers, and we will allocate them
* lazily as needed in select_fe_values().
*/
- dealii::Table<3,std_cxx11::shared_ptr<FEValuesType> > fe_values_table;
+ dealii::Table<3,std::shared_ptr<FEValuesType> > fe_values_table;
/**
* Set of indices pointing at the fe_values object selected last time
#include <deal.II/fe/fe.h>
#include <vector>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
+#include <memory>
DEAL_II_NAMESPACE_OPEN
* The real container, which stores pointers to the different Mapping
* objects.
*/
- std::vector<std_cxx11::shared_ptr<const Mapping<dim,spacedim> > > mappings;
+ std::vector<std::shared_ptr<const Mapping<dim,spacedim> > > mappings;
};
#include <deal.II/fe/fe.h>
#include <vector>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
+#include <memory>
DEAL_II_NAMESPACE_OPEN
* The real container, which stores pointers to the different quadrature
* objects.
*/
- std::vector<std_cxx11::shared_ptr<const Quadrature<dim> > > quadratures;
+ std::vector<std::shared_ptr<const Quadrature<dim> > > quadratures;
};
QCollection<dim>::QCollection (const Quadrature<dim> &quadrature)
{
quadratures
- .push_back (std_cxx11::shared_ptr<const Quadrature<dim> >(new Quadrature<dim>(quadrature)));
+ .push_back (std::shared_ptr<const Quadrature<dim> >(new Quadrature<dim>(quadrature)));
}
QCollection<dim>::push_back (const Quadrature<dim> &new_quadrature)
{
quadratures
- .push_back (std_cxx11::shared_ptr<const Quadrature<dim> >(new Quadrature<dim>(new_quadrature)));
+ .push_back (std::shared_ptr<const Quadrature<dim> >(new Quadrature<dim>(new_quadrature)));
}
} // namespace hp
* @author Uwe Koecher, 2017
*/
template <typename Number>
-struct is_serial_vector< BlockVector< Number > > : std_cxx11::true_type
+struct is_serial_vector< BlockVector< Number > > : std::true_type
{
};
(matrix_size+m()) / m();
if (matrix_size>grain_size)
parallel::apply_to_subranges (0U, matrix_size,
- std_cxx11::bind(&internal::ChunkSparseMatrix::template
- zero_subrange<number>,
- std_cxx11::_1, std_cxx11::_2,
- val),
+ std::bind(&internal::ChunkSparseMatrix::template
+ zero_subrange<number>,
+ std::placeholders::_1, std::placeholders::_2,
+ val),
grain_size);
else if (matrix_size > 0)
std::memset (&val[0], 0, matrix_size*sizeof(number));
return std::count_if(&val[0],
&val[cols->sparsity_pattern.n_nonzero_elements () *
chunk_size * chunk_size],
- std_cxx11::bind(std::not_equal_to<double>(), std_cxx11::_1, 0));
+ std::bind(std::not_equal_to<double>(), std::placeholders::_1, 0));
}
Assert (!PointerComparison::equal(&src, &dst), ExcSourceEqualsDestination());
parallel::apply_to_subranges (0U, cols->sparsity_pattern.n_rows(),
- std_cxx11::bind (&internal::ChunkSparseMatrix::vmult_add_on_subrange
- <number,InVector,OutVector>,
- std_cxx11::cref(*cols),
- std_cxx11::_1, std_cxx11::_2,
- val,
- cols->sparsity_pattern.rowstart,
- cols->sparsity_pattern.colnums,
- std_cxx11::cref(src),
- std_cxx11::ref(dst)),
+ std::bind (&internal::ChunkSparseMatrix::vmult_add_on_subrange
+ <number,InVector,OutVector>,
+ std::cref(*cols),
+ std::placeholders::_1, std::placeholders::_2,
+ val,
+ cols->sparsity_pattern.rowstart,
+ cols->sparsity_pattern.colnums,
+ std::cref(src),
+ std::ref(dst)),
internal::SparseMatrix::minimum_parallel_grain_size/cols->chunk_size+1);
}
*/
virtual void import(const ReadWriteVector<Number> &V,
VectorOperation::values operation,
- std_cxx11::shared_ptr<const CommunicationPatternBase> communication_pattern =
- std_cxx11::shared_ptr<const CommunicationPatternBase> ()) override;
+ std::shared_ptr<const CommunicationPatternBase> communication_pattern =
+ std::shared_ptr<const CommunicationPatternBase> ()) override;
/**
* Multiply the entive vector by a fixed factor.
/**
* Pointer to the sparsity pattern used for this matrix.
*/
- std
_cxx11::shared_ptr<PointerMatrixBase<VectorType> > matrix;
+ std::shared_ptr<PointerMatrixBase<VectorType> > matrix;
/**
* Sorted list of pairs denoting the index of the variable and the value to
/**
* The matrix in use.
*/
- std
_cxx11::shared_ptr<PointerMatrixBase<VectorType> > matrix;
+ std::shared_ptr<PointerMatrixBase<VectorType> > matrix;
/**
* The preconditioner to use.
*/
- std
_cxx11::shared_ptr<PointerMatrixBase<VectorType> > preconditioner;
+ std::shared_ptr<PointerMatrixBase<VectorType> > preconditioner;
};
IterativeInverse<VectorType>::initialize(const MatrixType &m, const PreconditionerType &p)
{
VectorType v;
- matrix = std
_cxx11::shared_ptr<PointerMatrixBase<VectorType> > (new_pointer_matrix_base(m, v));
- preconditioner = std
_cxx11::shared_ptr<PointerMatrixBase<VectorType> > (new_pointer_matrix_base(p, v));
+ matrix = std::shared_ptr<PointerMatrixBase<VectorType> > (new_pointer_matrix_base(m, v));
+ preconditioner = std::shared_ptr<PointerMatrixBase<VectorType> > (new_pointer_matrix_base(p, v));
}
*/
virtual void import(const LinearAlgebra::ReadWriteVector<Number> &V,
VectorOperation::values operation,
- std_cxx11::shared_ptr<const CommunicationPatternBase> communication_pattern =
- std_cxx11::shared_ptr<const CommunicationPatternBase> ());
+ std::shared_ptr<const CommunicationPatternBase> communication_pattern =
+ std::shared_ptr<const CommunicationPatternBase> ());
/**
* Return the scalar product of two vectors.
* @author Uwe Koecher, 2017
*/
template <typename Number>
-struct is_serial_vector< LinearAlgebra::distributed::BlockVector< Number > > : std_cxx11::false_type
+struct is_serial_vector< LinearAlgebra::distributed::BlockVector< Number > > : std::false_type
{
};
void
BlockVector<Number>::import(const LinearAlgebra::ReadWriteVector<Number> &,
VectorOperation::values,
- std_cxx11::shared_ptr<const CommunicationPatternBase>)
+ std::shared_ptr<const CommunicationPatternBase>)
{
AssertThrow(false, ExcNotImplemented());
}
#include <deal.II/base/mpi.h>
#include <deal.II/base/numbers.h>
#include <deal.II/base/partitioner.h>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
#include <deal.II/base/thread_management.h>
#include <deal.II/lac/vector_space_vector.h>
#include <deal.II/lac/vector_type_traits.h>
#include <iomanip>
+#include <memory>
DEAL_II_NAMESPACE_OPEN
* partitioner data only once and share it between several vectors with
* the same layout.
*/
- Vector (const std_cxx11::shared_ptr<const Utilities::MPI::Partitioner> &partitioner);
+ Vector (const std::shared_ptr<const Utilities::MPI::Partitioner> &partitioner);
/**
* Destructor.
* the partitioner data only once and share it between several vectors
* with the same layout.
*/
- void reinit (const std_cxx11::shared_ptr<const Utilities::MPI::Partitioner> &partitioner);
+ void reinit (const std::shared_ptr<const Utilities::MPI::Partitioner> &partitioner);
/**
* Swap the contents of this vector and the other vector @p v. One could
*/
virtual void import(const LinearAlgebra::ReadWriteVector<Number> &V,
VectorOperation::values operation,
- std_cxx11::shared_ptr<const CommunicationPatternBase> communication_pattern =
- std_cxx11::shared_ptr<const CommunicationPatternBase> ());
+ std::shared_ptr<const CommunicationPatternBase> communication_pattern =
+ std::shared_ptr<const CommunicationPatternBase> ());
/**
* Return the scalar product of two vectors.
* respective reinit() call, for additional queries regarding the
* parallel communication, or the compatibility of partitioners.
*/
- const std_cxx11::shared_ptr<const Utilities::MPI::Partitioner> &
+ const std::shared_ptr<const Utilities::MPI::Partitioner> &
get_partitioner () const;
/**
* information can be shared between several vectors that have the same
* partitioning.
*/
- std_cxx11::shared_ptr<const Utilities::MPI::Partitioner> partitioner;
+ std::shared_ptr<const Utilities::MPI::Partitioner> partitioner;
/**
* The size that is currently allocated in the val array.
* For parallel loops with TBB, this member variable stores the affinity
* information of loops.
*/
- mutable std_cxx11::shared_ptr< ::dealii::parallel::internal::TBBPartitioner> thread_loop_partitioner;
+ mutable std::shared_ptr< ::dealii::parallel::internal::TBBPartitioner> thread_loop_partitioner;
/**
* Temporary storage that holds the data that is sent to this processor
template <typename Number>
inline
- const std_cxx11::shared_ptr<const Utilities::MPI::Partitioner> &
+ const std::shared_ptr<const Utilities::MPI::Partitioner> &
Vector<Number>::get_partitioner () const
{
return partitioner;
* @author Uwe Koecher, 2017
*/
template <typename Number>
-struct is_serial_vector< LinearAlgebra::distributed::Vector< Number > > : std_cxx11::false_type
+struct is_serial_vector< LinearAlgebra::distributed::Vector< Number > > : std::false_type
{
};
const MPI_Comm communicator)
{
// set up parallel partitioner with index sets and communicator
- std_cxx11::shared_ptr<const Utilities::MPI::Partitioner> new_partitioner
+ std::shared_ptr<const Utilities::MPI::Partitioner> new_partitioner
(new Utilities::MPI::Partitioner (locally_owned_indices,
ghost_indices, communicator));
reinit (new_partitioner);
const MPI_Comm communicator)
{
// set up parallel partitioner with index sets and communicator
- std_cxx11::shared_ptr<const Utilities::MPI::Partitioner> new_partitioner
+ std::shared_ptr<const Utilities::MPI::Partitioner> new_partitioner
(new Utilities::MPI::Partitioner (locally_owned_indices,
communicator));
reinit (new_partitioner);
template <typename Number>
void
- Vector<Number>::reinit (const std_cxx11::shared_ptr<const Utilities::MPI::Partitioner> &partitioner_in)
+ Vector<Number>::reinit (const std::shared_ptr<const Utilities::MPI::Partitioner> &partitioner_in)
{
clear_mpi_requests();
partitioner = partitioner_in;
template <typename Number>
Vector<Number>::
- Vector (const std_cxx11::shared_ptr<const Utilities::MPI::Partitioner> &partitioner)
+ Vector (const std::shared_ptr<const Utilities::MPI::Partitioner> &partitioner)
:
allocated_size (0),
val (0),
void
Vector<Number>::import(const ReadWriteVector<Number> &V,
VectorOperation::values operation,
- std_cxx11::shared_ptr<const CommunicationPatternBase> communication_pattern)
+ std::shared_ptr<const CommunicationPatternBase> communication_pattern)
{
IndexSet locally_owned_elem = locally_owned_elements();
// If no communication pattern is given, create one. Otherwise, use the
// given one.
- std_cxx11::shared_ptr<const Utilities::MPI::Partitioner> comm_pattern;
+ std::shared_ptr<const Utilities::MPI::Partitioner> comm_pattern;
if (communication_pattern.get() == NULL)
{
// Split the IndexSet of V in locally owned elements and ghost indices
else
{
comm_pattern =
- std_cxx11::dynamic_pointer_cast<const Utilities::MPI::Partitioner> (communication_pattern);
+ std::dynamic_pointer_cast<const Utilities::MPI::Partitioner> (communication_pattern);
AssertThrow(comm_pattern != NULL,
ExcMessage("The communication pattern is not of type "
"Utilities::MPI::Partitioner."));
*/
virtual void import(const ReadWriteVector<Number> &V,
VectorOperation::values operation,
- std_cxx11::shared_ptr<const CommunicationPatternBase>
+ std::shared_ptr<const CommunicationPatternBase>
communication_pattern =
- std_cxx11::shared_ptr<const CommunicationPatternBase>());
+ std::shared_ptr<const CommunicationPatternBase>());
/**
* Add @p a to all components. Note that @p a is a scalar not a vector.
* @author Uwe Koecher, 2017
*/
template <typename Number>
-struct is_serial_vector< LinearAlgebra::Vector< Number > > : std_cxx11::true_type
+struct is_serial_vector< LinearAlgebra::Vector< Number > > : std::true_type
{
};
template <typename Number>
void Vector<Number>::import(const ReadWriteVector<Number> &,
VectorOperation::values ,
- std_cxx11::shared_ptr<const CommunicationPatternBase>)
+ std::shared_ptr<const CommunicationPatternBase>)
{
AssertThrow(false, ExcMessage("This function is not implemented."));
}
#include <deal.II/lac/lapack_support.h>
#include <deal.II/lac/vector_memory.h>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
+#include <memory>
#include <vector>
#include <complex>
* The matrix <i>U</i> in the singular value decomposition
* <i>USV<sup>T</sup></i>.
*/
- std_cxx11::shared_ptr<LAPACKFullMatrix<number> > svd_u;
+ std::shared_ptr<LAPACKFullMatrix<number> > svd_u;
/**
* The matrix <i>V<sup>T</sup></i> in the singular value decomposition
* <i>USV<sup>T</sup></i>.
*/
- std_cxx11::shared_ptr<LAPACKFullMatrix<number> > svd_vt;
+ std::shared_ptr<LAPACKFullMatrix<number> > svd_vt;
};
#include <deal.II/base/config.h>
#include <deal.II/base/smartpointer.h>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
#include <deal.II/base/memory_consumption.h>
#include <deal.II/base/mg_level_object.h>
#include <deal.II/lac/block_indices.h>
#include <deal.II/lac/full_matrix.h>
#include <deal.II/algorithms/any_data.h>
+#include <memory>
+
DEAL_II_NAMESPACE_OPEN
* The pointer type used for storing the objects. We use a shard pointer,
* such that they get deleted automatically when not used anymore.
*/
- typedef std_cxx11::shared_ptr<value_type> ptr_type;
+ typedef std::shared_ptr<value_type> ptr_type;
/**
* Add a new matrix block at the position <tt>(row,column)</tt> in the block
* @author Uwe Koecher, 2017
*/
template <>
-struct is_serial_vector< PETScWrappers::BlockVector > : std_cxx11::true_type
+struct is_serial_vector< PETScWrappers::BlockVector > : std::true_type
{
};
# include <deal.II/lac/vector.h>
# include <petscmat.h>
-# include <deal.II/base/std_cxx11/shared_ptr.h>
# include <vector>
# include <cmath>
+# include <memory>
DEAL_II_NAMESPACE_OPEN
* performance, we keep a shared pointer to these entries so that more
* than one accessor can access this data if necessary.
*/
- std_cxx11::shared_ptr<const std::vector<size_type> > colnum_cache;
+ std::shared_ptr<const std::vector<size_type> > colnum_cache;
/**
* Similar cache for the values of this row.
*/
- std
_cxx11::shared_ptr<const std::vector<PetscScalar> > value_cache;
+ std::shared_ptr<const std::vector<PetscScalar> > value_cache;
/**
* Discard the old row caches (they may still be used by other
* @author Uwe Koecher, 2017
*/
template <>
-struct is_serial_vector< PETScWrappers::MPI::BlockVector > : std_cxx11::false_type
+struct is_serial_vector< PETScWrappers::MPI::BlockVector > : std::false_type
{
};
* @author Uwe Koecher, 2017
*/
template <>
-struct is_serial_vector< PETScWrappers::MPI::Vector > : std_cxx11::false_type
+struct is_serial_vector< PETScWrappers::MPI::Vector > : std::false_type
{
};
# include <deal.II/lac/exceptions.h>
# include <deal.II/lac/solver_control.h>
-# include <deal.II/base/std_cxx11/shared_ptr.h>
# include <petscksp.h>
+# include <memory>
+
#ifdef DEAL_II_WITH_SLEPC
#include <deal.II/lac/slepc_spectral_transformation.h>
#endif
* Pointer to an object that stores the solver context. This is recreated
* in the main solver routine if necessary.
*/
- std_cxx11::shared_ptr<SolverData> solver_data;
+ std::shared_ptr<SolverData> solver_data;
#ifdef DEAL_II_WITH_SLEPC
/**
PC pc;
};
- std_cxx11::shared_ptr<SolverDataMUMPS> solver_data;
+ std::shared_ptr<SolverDataMUMPS> solver_data;
/**
* Flag specifies whether matrix being factorized is symmetric or not. It
* @author Uwe Koecher, 2017
*/
template <>
-struct is_serial_vector< PETScWrappers::Vector > : std_cxx11::true_type
+struct is_serial_vector< PETScWrappers::Vector > : std::true_type
{
};
/**
* Stores the preconditioner object that the Chebyshev is wrapped around.
*/
- std
_cxx11::shared_ptr<PreconditionerType> preconditioner;
+ std::shared_ptr<PreconditionerType> preconditioner;
};
DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
inline
void
initialize_preconditioner(const MatrixType &matrix,
- std
_cxx11::shared_ptr<PreconditionerType> &preconditioner,
+ std::shared_ptr<PreconditionerType> &preconditioner,
VectorType &)
{
(void)matrix;
inline
void
initialize_preconditioner(const MatrixType &matrix,
- std_cxx11::shared_ptr<DiagonalMatrix<VectorType> > &preconditioner,
+ std::shared_ptr<DiagonalMatrix<VectorType> > &preconditioner,
VectorType &diagonal_inverse)
{
if (preconditioner.get() == NULL ||
internal::PreconditionChebyshev::EigenvalueTracker eigenvalue_tracker;
SolverCG<VectorType> solver (control);
- solver.connect_eigenvalues_slot(std_cxx11::bind(&internal::PreconditionChebyshev::EigenvalueTracker::slot,
- &eigenvalue_tracker,
- std_cxx11::_1));
+ solver.connect_eigenvalues_slot(std::bind(&internal::PreconditionChebyshev::EigenvalueTracker::slot,
+ &eigenvalue_tracker,
+ std::placeholders::_1));
// set an initial guess which is close to the constant vector but where
// one entry is different to trigger high frequencies
*/
void import(const distributed::Vector<Number> &vec,
VectorOperation::values operation,
- std_cxx11::shared_ptr<const CommunicationPatternBase> communication_pattern =
- std_cxx11::shared_ptr<const CommunicationPatternBase> ());
+ std::shared_ptr<const CommunicationPatternBase> communication_pattern =
+ std::shared_ptr<const CommunicationPatternBase> ());
#ifdef DEAL_II_WITH_PETSC
/**
*/
void import(const PETScWrappers::MPI::Vector &petsc_vec,
VectorOperation::values operation,
- std_cxx11::shared_ptr<const CommunicationPatternBase> communication_pattern =
- std_cxx11::shared_ptr<const CommunicationPatternBase> ());
+ std::shared_ptr<const CommunicationPatternBase> communication_pattern =
+ std::shared_ptr<const CommunicationPatternBase> ());
#endif
#ifdef DEAL_II_WITH_TRILINOS
*/
void import(const TrilinosWrappers::MPI::Vector &trilinos_vec,
VectorOperation::values operation,
- std_cxx11::shared_ptr<const CommunicationPatternBase> communication_pattern =
- std_cxx11::shared_ptr<const CommunicationPatternBase> ());
+ std::shared_ptr<const CommunicationPatternBase> communication_pattern =
+ std::shared_ptr<const CommunicationPatternBase> ());
/**
* Imports all the elements present in the vector's IndexSet from the input
*/
void import(const EpetraWrappers::Vector &epetra_vec,
VectorOperation::values operation,
- std_cxx11::shared_ptr<const CommunicationPatternBase> communication_pattern =
- std_cxx11::shared_ptr<const CommunicationPatternBase> ());
+ std::shared_ptr<const CommunicationPatternBase> communication_pattern =
+ std::shared_ptr<const CommunicationPatternBase> ());
#endif
#ifdef DEAL_II_WITH_CUDA
*/
void import(const CUDAWrappers::Vector<Number> &cuda_vec,
VectorOperation::values operation,
- std_cxx11::shared_ptr<const CommunicationPatternBase> communication_pattern =
- std_cxx11::shared_ptr<const CommunicationPatternBase> ());
+ std::shared_ptr<const CommunicationPatternBase> communication_pattern =
+ std::shared_ptr<const CommunicationPatternBase> ());
#endif
/**
const IndexSet &locally_owned_elements,
VectorOperation::values operation,
const MPI_Comm &mpi_comm,
- std_cxx11::shared_ptr<const CommunicationPatternBase> communication_pattern);
+ std::shared_ptr<const CommunicationPatternBase> communication_pattern);
#endif
/**
* CommunicationPattern for the communication between the
* source_stored_elements IndexSet and the current vector.
*/
- std_cxx11::shared_ptr<CommunicationPatternBase> comm_pattern;
+ std::shared_ptr<CommunicationPatternBase> comm_pattern;
/**
* Pointer to the array of local elements of this vector.
* For parallel loops with TBB, this member variable stores the affinity
* information of loops.
*/
- mutable std_cxx11::shared_ptr< ::dealii::parallel::internal::TBBPartitioner> thread_loop_partitioner;
+ mutable std::shared_ptr< ::dealii::parallel::internal::TBBPartitioner> thread_loop_partitioner;
/**
* Make all other ReadWriteVector types friends.
void
ReadWriteVector<Number>::import(const distributed::Vector<Number> &vec,
VectorOperation::values operation,
- std_cxx11::shared_ptr<const CommunicationPatternBase> communication_pattern)
+ std::shared_ptr<const CommunicationPatternBase> communication_pattern)
{
// If no communication pattern is given, create one. Otherwise, use the
// given one.
- std_cxx11::shared_ptr<const Utilities::MPI::Partitioner> comm_pattern;
+ std::shared_ptr<const Utilities::MPI::Partitioner> comm_pattern;
if (communication_pattern.get() == NULL)
{
comm_pattern.reset(new Utilities::MPI::Partitioner(vec.locally_owned_elements(),
else
{
comm_pattern =
- std_cxx11::dynamic_pointer_cast<const Utilities::MPI::Partitioner> (communication_pattern);
+ std::dynamic_pointer_cast<const Utilities::MPI::Partitioner> (communication_pattern);
AssertThrow(comm_pattern != NULL,
ExcMessage("The communication pattern is not of type "
"Utilities::MPI::Partitioner."));
void
ReadWriteVector<Number>::import(const PETScWrappers::MPI::Vector &petsc_vec,
VectorOperation::values /*operation*/,
- std_cxx11::shared_ptr<const CommunicationPatternBase> /*communication_pattern*/)
+ std::shared_ptr<const CommunicationPatternBase> /*communication_pattern*/)
{
//TODO: this works only if no communication is needed.
Assert(petsc_vec.locally_owned_elements() == stored_elements,
const IndexSet &source_elements,
VectorOperation::values operation,
const MPI_Comm &mpi_comm,
- std_cxx11::shared_ptr<const CommunicationPatternBase> communication_pattern)
+ std::shared_ptr<const CommunicationPatternBase> communication_pattern)
{
- std_cxx11::shared_ptr<const EpetraWrappers::CommunicationPattern> epetra_comm_pattern;
+ std::shared_ptr<const EpetraWrappers::CommunicationPattern> epetra_comm_pattern;
// If no communication pattern is given, create one. Otherwise, use the one
// given.
(source_elements == source_stored_elements))
{
epetra_comm_pattern =
- std_cxx11::dynamic_pointer_cast<const EpetraWrappers::CommunicationPattern> (comm_pattern);
+ std::dynamic_pointer_cast<const EpetraWrappers::CommunicationPattern> (comm_pattern);
if (epetra_comm_pattern == NULL)
- epetra_comm_pattern = std_cxx11::make_shared<const EpetraWrappers::CommunicationPattern>(
+ epetra_comm_pattern = std::make_shared<const EpetraWrappers::CommunicationPattern>(
create_epetra_comm_pattern(source_elements, mpi_comm));
}
else
- epetra_comm_pattern = std_cxx11::make_shared<const EpetraWrappers::CommunicationPattern>(
+ epetra_comm_pattern = std::make_shared<const EpetraWrappers::CommunicationPattern>(
create_epetra_comm_pattern(source_elements, mpi_comm));
}
else
{
- epetra_comm_pattern = std_cxx11::dynamic_pointer_cast<const EpetraWrappers::CommunicationPattern> (
+ epetra_comm_pattern = std::dynamic_pointer_cast<const EpetraWrappers::CommunicationPattern> (
communication_pattern);
AssertThrow(epetra_comm_pattern != NULL,
ExcMessage(std::string("The communication pattern is not of type ") +
void
ReadWriteVector<Number>::import(const TrilinosWrappers::MPI::Vector &trilinos_vec,
VectorOperation::values operation,
- std_cxx11::shared_ptr<const CommunicationPatternBase> communication_pattern)
+ std::shared_ptr<const CommunicationPatternBase> communication_pattern)
{
import(trilinos_vec.trilinos_vector(), trilinos_vec.locally_owned_elements(),
operation, trilinos_vec.get_mpi_communicator(), communication_pattern);
void
ReadWriteVector<Number>::import(const LinearAlgebra::EpetraWrappers::Vector &trilinos_vec,
VectorOperation::values operation,
- std_cxx11::shared_ptr<const CommunicationPatternBase> communication_pattern)
+ std::shared_ptr<const CommunicationPatternBase> communication_pattern)
{
import(trilinos_vec.trilinos_vector(), trilinos_vec.locally_owned_elements(),
operation, trilinos_vec.get_mpi_communicator(), communication_pattern);
void
ReadWriteVector<Number>::import(const LinearAlgebra::CUDAWrappers::Vector<Number> &cuda_vec,
VectorOperation::values operation,
- std_cxx11::shared_ptr<const CommunicationPatternBase> )
+ std::shared_ptr<const CommunicationPatternBase> )
{
const unsigned int n_elements = stored_elements.n_elements();
if (operation == VectorOperation::insert)
{
// compute blocks in parallel
parallel::apply_to_subranges(0, this->additional_data->block_list.n_rows(),
- std_cxx11::bind(&RelaxationBlock<MatrixType, InverseNumberType, VectorType>::block_kernel, this,
- std_cxx11::_1, std_cxx11::_2),
+ std::bind(&RelaxationBlock<MatrixType, InverseNumberType, VectorType>::block_kernel, this,
+ std::placeholders::_1, std::placeholders::_2),
16);
}
this->inverses_computed(true);
#ifdef DEAL_II_WITH_SLEPC
-# include <deal.II/base/std_cxx11/shared_ptr.h>
-# include <deal.II/lac/exceptions.h>
# include <deal.II/lac/solver_control.h>
# include <deal.II/lac/petsc_matrix_base.h>
# include <deal.II/lac/slepc_spectral_transformation.h>
# include <petscksp.h>
# include <slepceps.h>
+# include <memory>
+
DEAL_II_NAMESPACE_OPEN
/**
#ifdef DEAL_II_WITH_SLEPC
-# include <deal.II/base/std_cxx11/shared_ptr.h>
# include <deal.II/lac/exceptions.h>
# include <deal.II/lac/petsc_solver.h>
# include <petscksp.h>
# include <slepceps.h>
+# include <memory>
+
DEAL_II_NAMESPACE_OPEN
namespace PETScWrappers
* function). A pointer to a function with this argument list satisfies the
* requirements, but you can also pass a member function whose
* <code>this</code> argument has been bound using the
- * <code>std_cxx11::bind</code> mechanism (see the example below). - Each of
+ * <code>std::bind</code> mechanism (see the example below). - Each of
* the slots will return a value that indicates whether the iteration should
* continue, should stop because it has succeeded, or stop because it has
* failed. The return type of slots is therefore of type SolverControl::State.
* SolverControl solver_control (1000, 1e-12);
* SolverCG<> solver (solver_control);
*
- * solver.connect (std_cxx11::bind (&Step3::write_intermediate_solution,
- * this,
- * std_cxx11::_1,
- * std_cxx11::_2,
- * std_cxx11::_3));
+ * solver.connect (std::bind (&Step3::write_intermediate_solution,
+ * this,
+ * std::placeholders::_1,
+ * std::placeholders::_2,
+ * std::placeholders::_3));
* solver.solve (system_matrix, solution, system_rhs,
* PreconditionIdentity());
* }
* @endcode
- * The use of <code>std_cxx11::bind</code> here ensures that we convert the
+ * The use of <code>std::bind</code> here ensures that we convert the
* member function with its three arguments plus the <code>this</code>
* pointer, to a function that only takes three arguments, by fixing the
* implicit <code>this</code> argument of the function to the
* library for more information on connection management.
*/
boost::signals2::connection
- connect (const std_cxx11::function<SolverControl::State (const unsigned int iteration,
- const double check_value,
- const VectorType ¤t_iterate)> &slot);
+ connect (const std::function<SolverControl::State (const unsigned int iteration,
+ const double check_value,
+ const VectorType ¤t_iterate)> &slot);
// only takes two arguments, the iteration and the check_value, and so
// we simply ignore the third argument that is passed in whenever the
// signal is executed
- connect (std_cxx11::bind(&SolverControl::check,
- std_cxx11::ref(solver_control),
- std_cxx11::_1,
- std_cxx11::_2));
+ connect (std::bind(&SolverControl::check,
+ std::ref(solver_control),
+ std::placeholders::_1,
+ std::placeholders::_2));
}
// only takes two arguments, the iteration and the check_value, and so
// we simply ignore the third argument that is passed in whenever the
// signal is executed
- connect (std_cxx11::bind(&SolverControl::check,
- std_cxx11::ref(solver_control),
- std_cxx11::_1,
- std_cxx11::_2));
+ connect (std::bind(&SolverControl::check,
+ std::ref(solver_control),
+ std::placeholders::_1,
+ std::placeholders::_2));
}
inline
boost::signals2::connection
Solver<VectorType>::
-connect (const std_cxx11::function<SolverControl::State (const unsigned int iteration,
- const double check_value,
- const VectorType ¤t_iterate)> &slot)
+connect (const std::function<SolverControl::State (const unsigned int iteration,
+ const double check_value,
+ const VectorType ¤t_iterate)> &slot)
{
return iteration_status.connect (slot);
}
*/
boost::signals2::connection
connect_coefficients_slot(
- const std_cxx11::function<void (double,double)> &slot);
+ const std::function<void (double,double)> &slot);
/**
* Connect a slot to retrieve the estimated condition number. Called on each
* divergence has been detected).
*/
boost::signals2::connection
- connect_condition_number_slot(const std_cxx11::function<void (double)> &slot,
+ connect_condition_number_slot(const std::function<void (double)> &slot,
const bool every_iteration=false);
/**
*/
boost::signals2::connection
connect_eigenvalues_slot(
- const std_cxx11::function<void (const std::vector<double> &)> &slot,
+ const std::function<void (const std::vector<double> &)> &slot,
const bool every_iteration=false);
protected:
template<typename VectorType>
boost::signals2::connection
SolverCG<VectorType>::connect_coefficients_slot
-(const std_cxx11::function<void(double,double)> &slot)
+(const std::function<void(double,double)> &slot)
{
return coefficients_signal.connect(slot);
}
template<typename VectorType>
boost::signals2::connection
SolverCG<VectorType>::connect_condition_number_slot
-(const std_cxx11::function<void(double)> &slot,
+(const std::function<void(double)> &slot,
const bool every_iteration)
{
if (every_iteration)
template<typename VectorType>
boost::signals2::connection
SolverCG<VectorType>::connect_eigenvalues_slot
-(const std_cxx11::function<void (const std::vector<double> &)> &slot,
+(const std::function<void (const std::vector<double> &)> &slot,
const bool every_iteration)
{
if (every_iteration)
* or because divergence has been detected).
*/
boost::signals2::connection
- connect_condition_number_slot(const std_cxx11::function<void (double)> &slot,
+ connect_condition_number_slot(const std::function<void (double)> &slot,
const bool every_iteration=false);
/**
*/
boost::signals2::connection
connect_eigenvalues_slot(
- const std_cxx11::function<void (const std::vector<std::complex<double> > &)> &slot,
+ const std::function<void (const std::vector<std::complex<double> > &)> &slot,
const bool every_iteration=false);
/**
*/
boost::signals2::connection
connect_hessenberg_slot(
- const std_cxx11::function<void (const FullMatrix<double> &)> &slot,
+ const std::function<void (const FullMatrix<double> &)> &slot,
const bool every_iteration=true);
/**
*/
boost::signals2::connection
connect_krylov_space_slot(
- const std_cxx11::function<void (const internal::SolverGMRES::TmpVectors<VectorType> &)> &slot);
+ const std::function<void (const internal::SolverGMRES::TmpVectors<VectorType> &)> &slot);
DeclException1 (ExcTooFewTmpVectors,
template<class VectorType>
boost::signals2::connection
SolverGMRES<VectorType>::connect_condition_number_slot
-(const std_cxx11::function<void(double)> &slot,
+(const std::function<void(double)> &slot,
const bool every_iteration)
{
if (every_iteration)
template<class VectorType>
boost::signals2::connection
SolverGMRES<VectorType>::connect_eigenvalues_slot
-(const std_cxx11::function<void (const std::vector<std::complex<double> > &)> &slot,
+(const std::function<void (const std::vector<std::complex<double> > &)> &slot,
const bool every_iteration)
{
if (every_iteration)
template<class VectorType>
boost::signals2::connection
SolverGMRES<VectorType>::connect_hessenberg_slot
-(const std_cxx11::function<void (const FullMatrix<double> &)> &slot,
+(const std::function<void (const FullMatrix<double> &)> &slot,
const bool every_iteration)
{
if (every_iteration)
template<class VectorType>
boost::signals2::connection
SolverGMRES<VectorType>::connect_krylov_space_slot
-(const std_cxx11::function<void (const internal::SolverGMRES::TmpVectors<VectorType> &)> &slot)
+(const std::function<void (const internal::SolverGMRES::TmpVectors<VectorType> &)> &slot)
{
return krylov_space_signal.connect(slot);
}
#include <cmath>
#include <vector>
#include <numeric>
-#include <deal.II/base/std_cxx11/bind.h>
+#include <functional>
(cols->n_nonzero_elements()+m()) / m();
if (matrix_size>grain_size)
parallel::apply_to_subranges (0U, matrix_size,
- std_cxx11::bind(&internal::SparseMatrix::template
- zero_subrange<number>,
- std_cxx11::_1, std_cxx11::_2,
- val),
+ std::bind(&internal::SparseMatrix::template
+ zero_subrange<number>,
+ std::placeholders::_1, std::placeholders::_2,
+ val),
grain_size);
else if (matrix_size > 0)
std::memset (&val[0], 0, matrix_size*sizeof(number));
Assert (!PointerComparison::equal(&src, &dst), ExcSourceEqualsDestination());
parallel::apply_to_subranges (0U, m(),
- std_cxx11::bind (&internal::SparseMatrix::vmult_on_subrange
- <number,InVector,OutVector>,
- std_cxx11::_1, std_cxx11::_2,
- val,
- cols->rowstart,
- cols->colnums,
- std_cxx11::cref(src),
- std_cxx11::ref(dst),
- false),
+ std::bind (&internal::SparseMatrix::vmult_on_subrange
+ <number,InVector,OutVector>,
+ std::placeholders::_1, std::placeholders::_2,
+ val,
+ cols->rowstart,
+ cols->colnums,
+ std::cref(src),
+ std::ref(dst),
+ false),
internal::SparseMatrix::minimum_parallel_grain_size);
}
Assert (!PointerComparison::equal(&src, &dst), ExcSourceEqualsDestination());
parallel::apply_to_subranges (0U, m(),
- std_cxx11::bind (&internal::SparseMatrix::vmult_on_subrange
- <number,InVector,OutVector>,
- std_cxx11::_1, std_cxx11::_2,
- val,
- cols->rowstart,
- cols->colnums,
- std_cxx11::cref(src),
- std_cxx11::ref(dst),
- true),
+ std::bind (&internal::SparseMatrix::vmult_on_subrange
+ <number,InVector,OutVector>,
+ std::placeholders::_1, std::placeholders::_2,
+ val,
+ cols->rowstart,
+ cols->colnums,
+ std::cref(src),
+ std::ref(dst),
+ true),
internal::SparseMatrix::minimum_parallel_grain_size);
}
return
parallel::accumulate_from_subranges<somenumber>
- (std_cxx11::bind (&internal::SparseMatrix::matrix_norm_sqr_on_subrange
- <number,Vector<somenumber> >,
- std_cxx11::_1, std_cxx11::_2,
- val, cols->rowstart, cols->colnums,
- std_cxx11::cref(v)),
+ (std::bind (&internal::SparseMatrix::matrix_norm_sqr_on_subrange
+ <number,Vector<somenumber> >,
+ std::placeholders::_1, std::placeholders::_2,
+ val, cols->rowstart, cols->colnums,
+ std::cref(v)),
0, m(),
internal::SparseMatrix::minimum_parallel_grain_size);
}
return
parallel::accumulate_from_subranges<somenumber>
- (std_cxx11::bind (&internal::SparseMatrix::matrix_scalar_product_on_subrange
- <number,Vector<somenumber> >,
- std_cxx11::_1, std_cxx11::_2,
- val, cols->rowstart, cols->colnums,
- std_cxx11::cref(u),
- std_cxx11::cref(v)),
+ (std::bind (&internal::SparseMatrix::matrix_scalar_product_on_subrange
+ <number,Vector<somenumber> >,
+ std::placeholders::_1, std::placeholders::_2,
+ val, cols->rowstart, cols->colnums,
+ std::cref(u),
+ std::cref(v)),
0, m(),
internal::SparseMatrix::minimum_parallel_grain_size);
}
return
std::sqrt (parallel::accumulate_from_subranges<somenumber>
- (std_cxx11::bind (&internal::SparseMatrix::residual_sqr_on_subrange
- <number,Vector<somenumber>,Vector<somenumber> >,
- std_cxx11::_1, std_cxx11::_2,
- val, cols->rowstart, cols->colnums,
- std_cxx11::cref(u),
- std_cxx11::cref(b),
- std_cxx11::ref(dst)),
+ (std::bind (&internal::SparseMatrix::residual_sqr_on_subrange
+ <number,Vector<somenumber>,Vector<somenumber> >,
+ std::placeholders::_1, std::placeholders::_2,
+ val, cols->rowstart, cols->colnums,
+ std::cref(u),
+ std::cref(b),
+ std::ref(dst)),
0, m(),
internal::SparseMatrix::minimum_parallel_grain_size));
}
* @author Uwe Koecher, 2017
*/
template <>
-struct is_serial_vector< TrilinosWrappers::BlockVector > : std_cxx11::true_type
+struct is_serial_vector< TrilinosWrappers::BlockVector > : std::true_type
{
};
* @author Uwe Koecher, 2017
*/
template <>
-struct is_serial_vector< TrilinosWrappers::MPI::BlockVector > : std_cxx11::false_type
+struct is_serial_vector< TrilinosWrappers::MPI::BlockVector > : std::false_type
{
};
#ifdef DEAL_II_WITH_MPI
-#include <deal.II/base/std_cxx11/shared_ptr.h>
#include <deal.II/lac/communication_pattern_base.h>
#include "Epetra_Import.h"
+#include <memory>
DEAL_II_NAMESPACE_OPEN
/**
* Shared pointer to the MPI communicator used.
*/
- std_cxx11::shared_ptr<const MPI_Comm> comm;
+ std::shared_ptr<const MPI_Comm> comm;
/**
* Shared pointer to the Epetra_Import object used.
*/
- std_cxx11::shared_ptr<Epetra_Import> import;
+ std::shared_ptr<Epetra_Import> import;
};
} // end of namespace EpetraWrappers
} // end of namespace LinearAlgebra
#ifdef DEAL_II_WITH_MPI
#include <deal.II/base/index_set.h>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
#include <deal.II/lac/read_write_vector.h>
#include <deal.II/lac/vector_space_vector.h>
#include <memory>
* This constructor takes an IndexSet that defines how to distribute the
* individual components among the MPI processors. Since it also
* includes information about the size of the vector, this is all we
- * need to genereate a %parallel vector.
+ * need to generate a %parallel vector.
*/
explicit Vector(const IndexSet ¶llel_partitioner,
const MPI_Comm &communicator);
*/
virtual void import(const ReadWriteVector<double> &V,
VectorOperation::values operation,
- std_cxx11::shared_ptr<const CommunicationPatternBase> communication_pattern =
- std_cxx11::shared_ptr<const CommunicationPatternBase> ());
+ std::shared_ptr<const CommunicationPatternBase> communication_pattern =
+ std::shared_ptr<const CommunicationPatternBase> ());
/**
* Multiply the entire vector by a fixed factor.
/**
* Pointer to the actual Epetra vector object.
*/
- std_cxx11::shared_ptr<Epetra_FEVector> vector;
+ std::shared_ptr<Epetra_FEVector> vector;
/**
* IndexSet of the elements of the last imported vector.
* CommunicationPattern for the communication between the
* source_stored_elements IndexSet and the current vector.
*/
- std_cxx11::shared_ptr<const CommunicationPattern> epetra_comm_pattern;
+ std::shared_ptr<const CommunicationPattern> epetra_comm_pattern;
};
}
}
#ifdef DEAL_II_WITH_TRILINOS
# include <deal.II/base/subscriptor.h>
-# include <deal.II/base/std_cxx11/shared_ptr.h>
# include <deal.II/lac/trilinos_vector_base.h>
# include <deal.II/lac/la_parallel_vector.h>
+# include <memory>
+
DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
# ifdef DEAL_II_WITH_MPI
# include <Epetra_MpiComm.h>
* This is a pointer to the preconditioner object that is used when
* applying the preconditioner.
*/
- std_cxx11::shared_ptr<Epetra_Operator> preconditioner;
+ std::shared_ptr<Epetra_Operator> preconditioner;
/**
* Internal communication pattern in case the matrix needs to be copied
* Internal Trilinos map in case the matrix needs to be copied from
* deal.II format.
*/
- std_cxx11::shared_ptr<Epetra_Map> vector_distributor;
+ std::shared_ptr<Epetra_Map> vector_distributor;
};
/**
* A copy of the deal.II matrix into Trilinos format.
*/
- std_cxx11::shared_ptr<SparseMatrix> trilinos_matrix;
+ std::shared_ptr<SparseMatrix> trilinos_matrix;
};
/**
* A copy of the deal.II matrix into Trilinos format.
*/
- std_cxx11::shared_ptr<SparseMatrix> trilinos_matrix;
+ std::shared_ptr<SparseMatrix> trilinos_matrix;
};
#endif
#ifdef DEAL_II_WITH_TRILINOS
-# include <deal.II/base/std_cxx11/shared_ptr.h>
# include <deal.II/lac/exceptions.h>
# include <deal.II/lac/solver_control.h>
# include <deal.II/lac/vector.h>
# include <deal.II/lac/la_parallel_vector.h>
+# include <memory>
+
DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
# include <Epetra_LinearProblem.h>
# include <AztecOO.h>
* side vector and the solution vector, which is passed down to the
* Trilinos solver.
*/
- std_cxx11::shared_ptr<Epetra_LinearProblem> linear_problem;
+ std::shared_ptr<Epetra_LinearProblem> linear_problem;
/**
* A structure that contains a Trilinos object that can query the linear
* solver and determine whether the convergence criterion have been met.
*/
- std
_cxx11::shared_ptr<AztecOO_StatusTest> status_test;
+ std::shared_ptr<AztecOO_StatusTest> status_test;
/**
* A structure that contains the Trilinos solver and preconditioner
* side vector and the solution vector, which is passed down to the
* Trilinos solver.
*/
- std_cxx11::shared_ptr<Epetra_LinearProblem> linear_problem;
+ std::shared_ptr<Epetra_LinearProblem> linear_problem;
/**
* A structure that contains the Trilinos solver and preconditioner
* objects.
*/
- std
_cxx11::shared_ptr<Amesos_BaseSolver> solver;
+ std::shared_ptr<Amesos_BaseSolver> solver;
/**
* Store a copy of the flags for this particular solver.
#ifdef DEAL_II_WITH_TRILINOS
-# include <deal.II/base/std_cxx11/shared_ptr.h>
# include <deal.II/base/subscriptor.h>
# include <deal.II/base/index_set.h>
# include <deal.II/lac/full_matrix.h>
* performance, we keep a shared pointer to these entries so that more
* than one accessor can access this data if necessary.
*/
- std_cxx11::shared_ptr<std::vector<size_type> > colnum_cache;
+ std::shared_ptr<std::vector<size_type> > colnum_cache;
/**
* Cache for the values of this row.
*/
- std_cxx11::shared_ptr<std::vector<TrilinosScalar> > value_cache;
+ std::shared_ptr<std::vector<TrilinosScalar> > value_cache;
};
/**
* Pointer to the user-supplied Epetra Trilinos mapping of the matrix
* columns that assigns parts of the matrix to the individual processes.
*/
- std_cxx11::shared_ptr<Epetra_Map> column_space_map;
+ std::shared_ptr<Epetra_Map> column_space_map;
/**
* A sparse matrix object in Trilinos to be used for finite element based
* problems which allows for assembling into non-local elements. The
* actual type, a sparse matrix, is set in the constructor.
*/
- std_cxx11::shared_ptr<Epetra_FECrsMatrix> matrix;
+ std::shared_ptr<Epetra_FECrsMatrix> matrix;
/**
* A sparse matrix object in Trilinos to be used for collecting the non-
* local elements if the matrix was constructed from a Trilinos sparsity
* pattern with the respective option.
*/
- std_cxx11::shared_ptr<Epetra_CrsMatrix> nonlocal_matrix;
+ std::shared_ptr<Epetra_CrsMatrix> nonlocal_matrix;
/**
* An export object used to communicate the nonlocal matrix.
*/
- std_cxx11::shared_ptr<Epetra_Export> nonlocal_matrix_exporter;
+ std::shared_ptr<Epetra_Export> nonlocal_matrix_exporter;
/**
* Trilinos doesn't allow to mix additions to matrix entries and
# include <cmath>
# include <memory>
-# include <deal.II/base/std_cxx11/shared_ptr.h>
DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
# include <Epetra_FECrsGraph.h>
* performance, we keep a shared pointer to these entries so that more
* than one accessor can access this data if necessary.
*/
- std_cxx11::shared_ptr<const std::vector<size_type> > colnum_cache;
+ std::shared_ptr<const std::vector<size_type> > colnum_cache;
/**
* Discard the old row caches (they may still be used by other
* Pointer to the user-supplied Epetra Trilinos mapping of the matrix
* columns that assigns parts of the matrix to the individual processes.
*/
- std_cxx11::shared_ptr<Epetra_Map> column_space_map;
+ std::shared_ptr<Epetra_Map> column_space_map;
/**
* A sparsity pattern object in Trilinos to be used for finite element
* based problems which allows for adding non-local elements to the
* pattern.
*/
- std_cxx11::shared_ptr<Epetra_FECrsGraph> graph;
+ std::shared_ptr<Epetra_FECrsGraph> graph;
/**
* A sparsity pattern object for the non-local part of the sparsity
* when the particular constructor or reinit method with writable_rows
* argument is set
*/
- std_cxx11::shared_ptr<Epetra_CrsGraph> nonlocal_graph;
+ std::shared_ptr<Epetra_CrsGraph> nonlocal_graph;
friend class TrilinosWrappers::SparseMatrix;
friend class SparsityPatternIterators::Accessor;
#ifdef DEAL_II_WITH_TRILINOS
-# include <deal.II/base/std_cxx11/shared_ptr.h>
# include <deal.II/base/subscriptor.h>
# include <deal.II/base/index_set.h>
# include <deal.II/base/utilities.h>
# include "Epetra_LocalMap.h"
DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
+#include <memory>
+
DEAL_II_NAMESPACE_OPEN
* @author Uwe Koecher, 2017
*/
template <>
-struct is_serial_vector< TrilinosWrappers::Vector > : std_cxx11::true_type
+struct is_serial_vector< TrilinosWrappers::Vector > : std::true_type
{
};
* @author Uwe Koecher, 2017
*/
template <>
-struct is_serial_vector< TrilinosWrappers::MPI::Vector > : std_cxx11::false_type
+struct is_serial_vector< TrilinosWrappers::MPI::Vector > : std::false_type
{
};
#ifdef DEAL_II_WITH_TRILINOS
#include <deal.II/base/utilities.h>
-# include <deal.II/base/std_cxx11/shared_ptr.h>
# include <deal.II/base/subscriptor.h>
# include <deal.II/lac/exceptions.h>
# include <deal.II/lac/vector.h>
* that is in fact distributed among multiple processors. The object
* requires an existing Epetra_Map for storing data when setting it up.
*/
- std_cxx11::shared_ptr<Epetra_FEVector> vector;
+ std::shared_ptr<Epetra_FEVector> vector;
/**
* A vector object in Trilinos to be used for collecting the non-local
* elements if the vector was constructed with an additional IndexSet
* describing ghost elements.
*/
- std_cxx11::shared_ptr<Epetra_MultiVector> nonlocal_vector;
+ std::shared_ptr<Epetra_MultiVector> nonlocal_vector;
/**
* An IndexSet storing the indices this vector owns exclusively.
* For parallel loops with TBB, this member variable stores the affinity
* information of loops.
*/
- mutable std
_cxx11::shared_ptr<parallel::internal::TBBPartitioner> thread_loop_partitioner;
+ mutable std::shared_ptr<parallel::internal::TBBPartitioner> thread_loop_partitioner;
/**
* Make all other vector types friends.
* @author Uwe Koecher, 2017
*/
template <typename Number>
-struct is_serial_vector< Vector<Number> > : std_cxx11::true_type
+struct is_serial_vector< Vector<Number> > : std::true_type
{
};
void parallel_for(Functor &functor,
size_type start,
size_type end,
- std
_cxx11::shared_ptr<parallel::internal::TBBPartitioner> &partitioner)
+ std::shared_ptr<parallel::internal::TBBPartitioner> &partitioner)
{
#ifdef DEAL_II_WITH_THREADS
size_type vec_size = end-start;
Assert(partitioner.get() != NULL,
ExcInternalError("Unexpected initialization of Vector that does "
"not set the TBB partitioner to a usable state."));
- std_cxx11::shared_ptr<tbb::affinity_partitioner> tbb_partitioner =
+ std::shared_ptr<tbb::affinity_partitioner> tbb_partitioner =
partitioner->acquire_one_partitioner();
TBBForFunctor<Functor> generic_functor(functor, start, end);
const size_type start,
const size_type end,
ResultType &result,
- std
_cxx11::shared_ptr<parallel::internal::TBBPartitioner> &partitioner)
+ std::shared_ptr<parallel::internal::TBBPartitioner> &partitioner)
{
#ifdef DEAL_II_WITH_THREADS
size_type vec_size = end-start;
Assert(partitioner.get() != NULL,
ExcInternalError("Unexpected initialization of Vector that does "
"not set the TBB partitioner to a usable state."));
- std_cxx11::shared_ptr<tbb::affinity_partitioner> tbb_partitioner =
+ std::shared_ptr<tbb::affinity_partitioner> tbb_partitioner =
partitioner->acquire_one_partitioner();
TBBReduceFunctor<Operation,ResultType> generic_functor(op, start, end);
#include <deal.II/base/config.h>
#include <deal.II/base/numbers.h>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
#include <deal.II/lac/vector.h>
+#include <memory>
+
DEAL_II_NAMESPACE_OPEN
*/
virtual void import(const ReadWriteVector<Number> &V,
VectorOperation::values operation,
- std_cxx11::shared_ptr<const CommunicationPatternBase> communication_pattern =
- std_cxx11::shared_ptr<const CommunicationPatternBase> ()) = 0;
+ std::shared_ptr<const CommunicationPatternBase> communication_pattern =
+ std::shared_ptr<const CommunicationPatternBase> ()) = 0;
/**
* Return the scalar product of two vectors.
#ifndef dealii__vector_type_traits_h
#define dealii__vector_type_traits_h
-#include <deal.II/base/std_cxx11/type_traits.h>
+#include <deal.II/base/config.h>
+
+#include <type_traits>
DEAL_II_NAMESPACE_OPEN
* The specialization
* @code
* template <>
- * struct is_serial_vector< VectorType > : std_cxx11::true_type {};
+ * struct is_serial_vector< VectorType > : std::true_type {};
* @endcode
* for a serial vector type, respectively,
* @code
* template <>
- * struct is_serial_vector< VectorType > : std_cxx11::false_type {};
+ * struct is_serial_vector< VectorType > : std::false_type {};
* @endcode
* for a vector type with support of distributed storage,
* must be done in a header file of a vector declaration.
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/matrix_free/helper_functions.h>
-#include <deal.II/base/std_cxx11/array.h>
-
+#include <array>
#include <memory>
* certain structure in the indices, like indices for vector-valued
* problems or for cells where not all vector components are filled.
*/
- std::vector<std_cxx11::array<unsigned int, 3> > row_starts;
+ std::vector<std::array<unsigned int, 3> > row_starts;
/**
* Stores the indices of the degrees of freedom for each cell. These
* in the vector, and also includes how the ghosts look like. This
* enables initialization of vectors based on the DoFInfo field.
*/
- std_cxx11::shared_ptr<const Utilities::MPI::Partitioner> vector_partitioner;
+ std::shared_ptr<const Utilities::MPI::Partitioner> vector_partitioner;
/**
* This stores a (sorted) list of all locally owned degrees of freedom
std::swap (new_active_fe_index, cell_active_fe_index);
}
- std::vector<std_cxx11::array<unsigned int, 3> > new_row_starts;
+ std::vector<std::array<unsigned int, 3> > new_row_starts;
std::vector<unsigned int> new_dof_indices;
std::vector<std::pair<unsigned short,unsigned short> >
new_constraint_indicator;
DoFInfo::memory_consumption () const
{
std::size_t memory = sizeof(*this);
- memory += (row_starts.capacity()*sizeof(std_cxx11::array<unsigned int,3>));
+ memory += (row_starts.capacity()*sizeof(std::array<unsigned int,3>));
memory += MemoryConsumption::memory_consumption (dof_indices);
memory += MemoryConsumption::memory_consumption (row_starts_plain_indices);
memory += MemoryConsumption::memory_consumption (plain_dof_indices);
{
out << " Memory row starts indices: ";
size_info.print_memory_statistics
- (out, (row_starts.capacity()*sizeof(std_cxx11::array<unsigned int, 3>)));
+ (out, (row_starts.capacity()*sizeof(std::array<unsigned int, 3>)));
out << " Memory dof indices: ";
size_info.print_memory_statistics
(out, MemoryConsumption::memory_consumption (dof_indices));
* Geometry data that can be generated FEValues on the fly with the
* respective constructor.
*/
- std_cxx1x::shared_ptr<internal::MatrixFreeFunctions::MappingDataOnTheFly<dim,Number> > mapped_geometry;
+ std::shared_ptr<internal::MatrixFreeFunctions::MappingDataOnTheFly<dim,Number> > mapped_geometry;
/**
* For use with on-the-fly evaluation, provide a data structure to store the
// hp::DoFHandler<dim>::active_cell_iterator, we need to manually
// select the correct finite element, so just hold a vector of
// FEValues
- std::vector<std_cxx11::shared_ptr<dealii::FEValues<dim> > >
+ std::vector<std::shared_ptr<dealii::FEValues<dim> > >
fe_values (current_data.quadrature.size());
UpdateFlags update_flags_feval =
((update_flags & update_inverse_jacobians) ? update_jacobians : update_default) |
* to the function object.
*/
template <typename OutVector, typename InVector>
- void cell_loop (const std_cxx11::function<void (const MatrixFree<dim,Number> &,
- OutVector &,
- const InVector &,
- const std::pair<unsigned int,
- unsigned int> &)> &cell_operation,
+ void cell_loop (const std::function<void (const MatrixFree<dim,Number> &,
+ OutVector &,
+ const InVector &,
+ const std::pair<unsigned int,
+ unsigned int> &)> &cell_operation,
OutVector &dst,
const InVector &src) const;
* a function pointer to a member function of class @p CLASS with the
* signature <code>cell_operation (const MatrixFree<dim,Number> &, OutVector
* &, InVector &, std::pair<unsigned int,unsigned int>&)const</code>. This
- * method obviates the need to call std_cxx11::bind to bind the class into
+ * method obviates the need to call std::bind to bind the class into
* the given function in case the local function needs to access data in the
* class (i.e., it is a non-static member function).
*/
* usually prefer this data structure as the data exchange information can
* be reused from one vector to another.
*/
- const std_cxx11::shared_ptr<const Utilities::MPI::Partitioner> &
+ const std::shared_ptr<const Utilities::MPI::Partitioner> &
get_vector_partitioner (const unsigned int vector_component=0) const;
/**
template <int dim, typename Number>
inline
-const std_cxx11::shared_ptr<const Utilities::MPI::Partitioner> &
+const std::shared_ptr<const Utilities::MPI::Partitioner> &
MatrixFree<dim,Number>::get_vector_partitioner (const unsigned int comp) const
{
AssertIndexRange (comp, n_components());
inline
void
MatrixFree<dim, Number>::cell_loop
-(const std_cxx11::function<void (const MatrixFree<dim,Number> &,
- OutVector &,
- const InVector &,
- const std::pair<unsigned int,
- unsigned int> &)> &cell_operation,
+(const std::function<void (const MatrixFree<dim,Number> &,
+ OutVector &,
+ const InVector &,
+ const std::pair<unsigned int,
+ unsigned int> &)> &cell_operation,
OutVector &dst,
const InVector &src) const
{
// to simplify the function calls, bind away all arguments except the
// cell range
typedef
- std_cxx11::function<void (const std::pair<unsigned int,unsigned int> &range)>
+ std::function<void (const std::pair<unsigned int,unsigned int> &range)>
Worker;
- const Worker func = std_cxx11::bind (std_cxx11::ref(cell_operation),
- std_cxx11::cref(*this),
- std_cxx11::ref(dst),
- std_cxx11::cref(src),
- std_cxx11::_1);
+ const Worker func = std::bind (std::ref(cell_operation),
+ std::cref(*this),
+ std::ref(dst),
+ std::cref(src),
+ std::placeholders::_1);
if (task_info.use_partition_partition == true)
{
OutVector &dst,
const InVector &src) const
{
- // here, use std_cxx11::bind to hand a function handler with the appropriate
+ // here, use std::bind to hand a function handler with the appropriate
// argument to the other loop function
- std_cxx11::function<void (const MatrixFree<dim,Number> &,
- OutVector &,
- const InVector &,
- const std::pair<unsigned int,
- unsigned int> &)>
- function = std_cxx11::bind<void>(function_pointer,
- owning_class,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3,
- std_cxx11::_4);
+ std::function<void (const MatrixFree<dim,Number> &,
+ OutVector &,
+ const InVector &,
+ const std::pair<unsigned int,
+ unsigned int> &)>
+ function = std::bind<void>(function_pointer,
+ owning_class,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3,
+ std::placeholders::_4);
cell_loop (function, dst, src);
}
OutVector &dst,
const InVector &src) const
{
- // here, use std_cxx11::bind to hand a function handler with the appropriate
+ // here, use std::bind to hand a function handler with the appropriate
// argument to the other loop function
- std_cxx11::function<void (const MatrixFree<dim,Number> &,
- OutVector &,
- const InVector &,
- const std::pair<unsigned int,
- unsigned int> &)>
- function = std_cxx11::bind<void>(function_pointer,
- owning_class,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3,
- std_cxx11::_4);
+ std::function<void (const MatrixFree<dim,Number> &,
+ OutVector &,
+ const InVector &,
+ const std::pair<unsigned int,
+ unsigned int> &)>
+ function = std::bind<void>(function_pointer,
+ owning_class,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3,
+ std::placeholders::_4);
cell_loop (function, dst, src);
}
// workaroud for unifying non-block vector and block vector implementations
// a non-block vector has one block and the only subblock is the vector itself
template <typename VectorType>
- typename std_cxx11::enable_if<IsBlockVector<VectorType>::value,
+ typename std::enable_if<IsBlockVector<VectorType>::value,
unsigned int>::type
n_blocks(const VectorType &vector)
{
}
template <typename VectorType>
- typename std_cxx11::enable_if<!IsBlockVector<VectorType>::value,
+ typename std::enable_if<!IsBlockVector<VectorType>::value,
unsigned int>::type
n_blocks(const VectorType &)
{
}
template <typename VectorType>
- typename std_cxx11::enable_if<IsBlockVector<VectorType>::value,
+ typename std::enable_if<IsBlockVector<VectorType>::value,
typename VectorType::BlockType &>::type
subblock(VectorType &vector, unsigned int block_no)
{
}
template <typename VectorType>
- typename std_cxx11::enable_if<IsBlockVector<VectorType>::value,
+ typename std::enable_if<IsBlockVector<VectorType>::value,
const typename VectorType::BlockType &>::type
subblock(const VectorType &vector, unsigned int block_no)
{
}
template <typename VectorType>
- typename std_cxx11::enable_if<!IsBlockVector<VectorType>::value,
+ typename std::enable_if<!IsBlockVector<VectorType>::value,
VectorType &>::type
subblock(VectorType &vector, unsigned int)
{
}
template <typename VectorType>
- typename std_cxx11::enable_if<!IsBlockVector<VectorType>::value,
+ typename std::enable_if<!IsBlockVector<VectorType>::value,
const VectorType &>::type
subblock(const VectorType &vector, unsigned int)
{
}
template <typename VectorType>
- typename std_cxx11::enable_if<IsBlockVector<VectorType>::value,
+ typename std::enable_if<IsBlockVector<VectorType>::value,
void>::type
collect_sizes(VectorType &vector)
{
}
template <typename VectorType>
- typename std_cxx11::enable_if<!IsBlockVector<VectorType>::value,
+ typename std::enable_if<!IsBlockVector<VectorType>::value,
void>::type
collect_sizes(const VectorType &)
{}
* column selection vector is empty, it is taken the same as the row
* selection, defining a diagonal block.
*/
- void initialize (std_cxx11::shared_ptr<const MatrixFree<dim,value_type> > data,
+ void initialize (std::shared_ptr<const MatrixFree<dim,value_type> > data,
const std::vector<unsigned int> &selected_row_blocks = std::vector<unsigned int>(),
const std::vector<unsigned int> &selected_column_blocks = std::vector<unsigned int>());
* columns is used as opposed to the non-level initialization function. If
* empty, all components are selected.
*/
- void initialize (std_cxx11::shared_ptr<const MatrixFree<dim,value_type> > data,
+ void initialize (std::shared_ptr<const MatrixFree<dim,value_type> > data,
const MGConstrainedDoFs &mg_constrained_dofs,
const unsigned int level,
const std::vector<unsigned int> &selected_row_blocks = std::vector<unsigned int>());
* empty, all components are selected.
*/
void
- initialize(std_cxx11::shared_ptr<const MatrixFree<dim, value_type> > data_,
+ initialize(std::shared_ptr<const MatrixFree<dim, value_type> > data_,
const std::vector<MGConstrainedDoFs> &mg_constrained_dofs,
const unsigned int level,
const std::vector<unsigned int> &selected_row_blocks = std::vector<unsigned int>());
/**
* Get read access to the MatrixFree object stored with this operator.
*/
- std_cxx11::shared_ptr<const MatrixFree<dim,value_type> >
+ std::shared_ptr<const MatrixFree<dim,value_type> >
get_matrix_free () const;
/**
* Get read access to the inverse diagonal of this operator.
*/
- const std_cxx11::shared_ptr<DiagonalMatrix<VectorType> > &
+ const std::shared_ptr<DiagonalMatrix<VectorType> > &
get_matrix_diagonal_inverse() const;
/**
/**
* MatrixFree object to be used with this operator.
*/
- std_cxx11::shared_ptr<const MatrixFree<dim,value_type> > data;
+ std::shared_ptr<const MatrixFree<dim,value_type> > data;
/**
* A shared pointer to a diagonal matrix that stores the inverse of
* diagonal elements as a vector.
*/
- std_cxx11::shared_ptr<DiagonalMatrix<VectorType > > inverse_diagonal_entries;
+ std::shared_ptr<DiagonalMatrix<VectorType > > inverse_diagonal_entries;
/**
* A vector which defines the selection of sub-components of MatrixFree
*
* Such tables can be initialized by
* @code
- * std
_cxx11::shared_ptr<Table<2, VectorizedArray<double> > > coefficient;
- * coefficient = std
_cxx11::make_shared<Table<2, VectorizedArray<double> > >();
+ * std::shared_ptr<Table<2, VectorizedArray<double> > > coefficient;
+ * coefficient = std::make_shared<Table<2, VectorizedArray<double> > >();
* {
* FEEvaluation<dim,fe_degree,n_q_points_1d,1,double> fe_eval(mf_data);
* const unsigned int n_cells = mf_data.n_macro_cells();
* of scope in user code and the clear() command or destructor of this class
* will delete the table.
*/
- void set_coefficient(const std
_cxx11::shared_ptr<Table<2, VectorizedArray<value_type> > > &scalar_coefficient );
+ void set_coefficient(const std::shared_ptr<Table<2, VectorizedArray<value_type> > > &scalar_coefficient );
virtual void clear();
* The function will throw an error if coefficients are not previously set
* by set_coefficient() function.
*/
- std_cxx11::shared_ptr< Table<2, VectorizedArray<value_type> > > get_coefficient();
+ std::shared_ptr< Table<2, VectorizedArray<value_type> > > get_coefficient();
private:
/**
/**
* User-provided heterogeneity coefficient.
*/
- std_cxx11::shared_ptr< Table<2, VectorizedArray<value_type> > > scalar_coefficient;
+ std::shared_ptr< Table<2, VectorizedArray<value_type> > > scalar_coefficient;
};
template <int dim, typename VectorType>
void
Base<dim,VectorType>::
- initialize (std_cxx11::shared_ptr<const MatrixFree<dim,typename Base<dim,VectorType>::value_type> > data_,
+ initialize (std::shared_ptr<const MatrixFree<dim,typename Base<dim,VectorType>::value_type> > data_,
const std::vector<unsigned int> &given_row_selection,
const std::vector<unsigned int> &given_column_selection)
{
template <int dim, typename VectorType>
void
Base<dim,VectorType>::
- initialize (std_cxx11::shared_ptr<const MatrixFree<dim,typename Base<dim,VectorType>::value_type> > data_,
+ initialize (std::shared_ptr<const MatrixFree<dim,typename Base<dim,VectorType>::value_type> > data_,
const MGConstrainedDoFs &mg_constrained_dofs,
const unsigned int level,
const std::vector<unsigned int> &given_row_selection)
template <int dim, typename VectorType>
void
Base<dim, VectorType>::
- initialize (std_cxx11::shared_ptr<const MatrixFree<dim, value_type> > data_,
+ initialize (std::shared_ptr<const MatrixFree<dim, value_type> > data_,
const std::vector<MGConstrainedDoFs> &mg_constrained_dofs,
const unsigned int level,
const std::vector<unsigned int> &given_row_selection)
template <int dim, typename VectorType>
- std_cxx11::shared_ptr<const MatrixFree<dim,typename Base<dim,VectorType>::value_type> >
+ std::shared_ptr<const MatrixFree<dim,typename Base<dim,VectorType>::value_type> >
Base<dim,VectorType>::get_matrix_free() const
{
return data;
template <int dim, typename VectorType>
- const std_cxx11::shared_ptr<DiagonalMatrix<VectorType> > &
+ const std::shared_ptr<DiagonalMatrix<VectorType> > &
Base<dim,VectorType>::get_matrix_diagonal_inverse() const
{
Assert(inverse_diagonal_entries.get() != NULL &&
template <int dim, int fe_degree, int n_q_points_1d, int n_components, typename VectorType>
void
LaplaceOperator<dim, fe_degree, n_q_points_1d, n_components, VectorType>::
- set_coefficient(const std
_cxx11::shared_ptr<Table<2, VectorizedArray<typename Base<dim,VectorType>::value_type> > > &scalar_coefficient_ )
+ set_coefficient(const std::shared_ptr<Table<2, VectorizedArray<typename Base<dim,VectorType>::value_type> > > &scalar_coefficient_ )
{
scalar_coefficient = scalar_coefficient_;
}
template <int dim, int fe_degree, int n_q_points_1d, int n_components, typename VectorType>
- std_cxx11::shared_ptr< Table<2, VectorizedArray< typename LaplaceOperator<dim, fe_degree, n_q_points_1d, n_components, VectorType>::value_type> > >
+ std::shared_ptr< Table<2, VectorizedArray< typename LaplaceOperator<dim, fe_degree, n_q_points_1d, n_components, VectorType>::value_type> > >
LaplaceOperator<dim, fe_degree, n_q_points_1d, n_components, VectorType>::
get_coefficient()
{
#include <deal.II/base/config.h>
#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
#include <deal.II/dofs/block_info.h>
#include <deal.II/fe/fe_values.h>
#include <deal.II/meshworker/local_results.h>
#include <deal.II/meshworker/vector_selector.h>
+#include <memory>
+
DEAL_II_NAMESPACE_OPEN
namespace MeshWorker
#include <deal.II/base/config.h>
#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
#include <deal.II/dofs/block_info.h>
#include <deal.II/fe/fe_values.h>
#include <deal.II/meshworker/local_results.h>
#include <deal.II/meshworker/dof_info.h>
#include <deal.II/meshworker/vector_selector.h>
+#include <memory>
+
DEAL_II_NAMESPACE_OPEN
namespace MeshWorker
{
private:
/// vector of FEValues objects
- std::vector<std_cxx11::shared_ptr<FEValuesBase<dim, spacedim> > > fevalv;
+ std::vector<std::shared_ptr<FEValuesBase<dim, spacedim> > > fevalv;
public:
static const unsigned int dimension = dim;
static const unsigned int space_dimension = spacedim;
/**
* Initialize the data vector and cache the selector.
*/
- void initialize_data(const std_cxx11::shared_ptr<VectorDataBase<dim,spacedim> > &data);
+ void initialize_data(const std::shared_ptr<VectorDataBase<dim,spacedim> > &data);
/**
* Delete the data created by initialize().
* The global data vector used to compute function values in quadrature
* points.
*/
- std_cxx11::shared_ptr<VectorDataBase<dim, spacedim> > global_data;
+ std::shared_ptr<VectorDataBase<dim, spacedim> > global_data;
/**
* The memory used by this object.
*/
MeshWorker::VectorSelector face_selector;
- std_cxx11::shared_ptr<MeshWorker::VectorDataBase<dim, spacedim> > cell_data;
- std_cxx11::shared_ptr<MeshWorker::VectorDataBase<dim, spacedim> > boundary_data;
- std_cxx11::shared_ptr<MeshWorker::VectorDataBase<dim, spacedim> > face_data;
+ std::shared_ptr<MeshWorker::VectorDataBase<dim, spacedim> > cell_data;
+ std::shared_ptr<MeshWorker::VectorDataBase<dim, spacedim> > boundary_data;
+ std::shared_ptr<MeshWorker::VectorDataBase<dim, spacedim> > face_data;
/* @} */
/**
:
fevalv(0),
multigrid(false),
- global_data(std_cxx11::shared_ptr<VectorDataBase<dim, sdim> >(new VectorDataBase<dim, sdim>)),
+ global_data(std::shared_ptr<VectorDataBase<dim, sdim> >(new VectorDataBase<dim, sdim>)),
n_components(numbers::invalid_unsigned_int)
{}
const FESubfaceValues<dim,sdim> *ps = dynamic_cast<const FESubfaceValues<dim,sdim>*>(&p);
if (pc != 0)
- fevalv[i] = std_cxx11::shared_ptr<FEValuesBase<dim,sdim> > (
+ fevalv[i] = std::shared_ptr<FEValuesBase<dim,sdim> > (
new FEValues<dim,sdim> (pc->get_mapping(), pc->get_fe(),
pc->get_quadrature(), pc->get_update_flags()));
else if (pf != 0)
- fevalv[i] = std_cxx11::shared_ptr<FEValuesBase<dim,sdim> > (
+ fevalv[i] = std::shared_ptr<FEValuesBase<dim,sdim> > (
new FEFaceValues<dim,sdim> (pf->get_mapping(), pf->get_fe(), pf->get_quadrature(), pf->get_update_flags()));
else if (ps != 0)
- fevalv[i] = std_cxx11::shared_ptr<FEValuesBase<dim,sdim> > (
+ fevalv[i] = std::shared_ptr<FEValuesBase<dim,sdim> > (
new FESubfaceValues<dim,sdim> (ps->get_mapping(), ps->get_fe(), ps->get_quadrature(), ps->get_update_flags()));
else
Assert(false, ExcInternalError());
if (block_info == 0 || block_info->local().size() == 0)
{
fevalv.resize(1);
- fevalv[0] = std_cxx11::shared_ptr<FEValuesBase<dim,sdim> > (
+ fevalv[0] = std::shared_ptr<FEValuesBase<dim,sdim> > (
new FEVALUES (mapping, el, quadrature, flags));
}
else
fevalv.resize(el.n_base_elements());
for (unsigned int i=0; i<fevalv.size(); ++i)
{
- fevalv[i] = std_cxx11::shared_ptr<FEValuesBase<dim,sdim> > (
+ fevalv[i] = std::shared_ptr<FEValuesBase<dim,sdim> > (
new FEVALUES (mapping, el.base_element(i), quadrature, flags));
}
}
const BlockInfo *block_info)
{
initialize(el, mapping, block_info);
- std_cxx11::shared_ptr<VectorData<VectorType, dim, sdim> > p;
+ std::shared_ptr<VectorData<VectorType, dim, sdim> > p;
VectorDataBase<dim,sdim> *pp;
- p = std_cxx11::shared_ptr<VectorData<VectorType, dim, sdim> >(new VectorData<VectorType, dim, sdim> (cell_selector));
+ p = std::shared_ptr<VectorData<VectorType, dim, sdim> >(new VectorData<VectorType, dim, sdim> (cell_selector));
// Public member function of parent class was not found without
// explicit cast
pp = &*p;
cell_data = p;
cell.initialize_data(p);
- p = std_cxx11::shared_ptr<VectorData<VectorType, dim, sdim> >(new VectorData<VectorType, dim, sdim> (boundary_selector));
+ p = std::shared_ptr<VectorData<VectorType, dim, sdim> >(new VectorData<VectorType, dim, sdim> (boundary_selector));
pp = &*p;
pp->initialize(data);
boundary_data = p;
boundary.initialize_data(p);
- p = std_cxx11::shared_ptr<VectorData<VectorType, dim, sdim> >(new VectorData<VectorType, dim, sdim> (face_selector));
+ p = std::shared_ptr<VectorData<VectorType, dim, sdim> >(new VectorData<VectorType, dim, sdim> (face_selector));
pp = &*p;
pp->initialize(data);
face_data = p;
const BlockInfo *block_info)
{
initialize(el, mapping, block_info);
- std_cxx11::shared_ptr<MGVectorData<VectorType, dim, sdim> > p;
+ std::shared_ptr<MGVectorData<VectorType, dim, sdim> > p;
VectorDataBase<dim,sdim> *pp;
- p = std_cxx11::shared_ptr<MGVectorData<VectorType, dim, sdim> >(new MGVectorData<VectorType, dim, sdim> (cell_selector));
+ p = std::shared_ptr<MGVectorData<VectorType, dim, sdim> >(new MGVectorData<VectorType, dim, sdim> (cell_selector));
// Public member function of parent class was not found without
// explicit cast
pp = &*p;
cell_data = p;
cell.initialize_data(p);
- p = std_cxx11::shared_ptr<MGVectorData<VectorType, dim, sdim> >(new MGVectorData<VectorType, dim, sdim> (boundary_selector));
+ p = std::shared_ptr<MGVectorData<VectorType, dim, sdim> >(new MGVectorData<VectorType, dim, sdim> (boundary_selector));
pp = &*p;
pp->initialize(data);
boundary_data = p;
boundary.initialize_data(p);
- p = std_cxx11::shared_ptr<MGVectorData<VectorType, dim, sdim> >(new MGVectorData<VectorType, dim, sdim> (face_selector));
+ p = std::shared_ptr<MGVectorData<VectorType, dim, sdim> >(new MGVectorData<VectorType, dim, sdim> (face_selector));
pp = &*p;
pp->initialize(data);
face_data = p;
template<int dim, int sdim>
void
IntegrationInfo<dim,sdim>::initialize_data(
- const std_cxx11::shared_ptr<VectorDataBase<dim,sdim> > &data)
+ const std::shared_ptr<VectorDataBase<dim,sdim> > &data)
{
global_data = data;
const unsigned int nqp = fevalv[0]->n_quadrature_points;
#include <deal.II/base/config.h>
#include <deal.II/base/subscriptor.h>
-#include <deal.II/base/std_cxx11/function.h>
+#include <functional>
#include <vector>
#include <string>
#define dealii__mesh_worker_local_results_h
#include <deal.II/base/config.h>
-#include <deal.II/base/std_cxx11/function.h>
#include <deal.II/base/geometry_info.h>
#include <deal.II/lac/matrix_block.h>
#include <deal.II/lac/block_vector.h>
#include <deal.II/meshworker/vector_selector.h>
+#include <functional>
+
DEAL_II_NAMESPACE_OPEN
class BlockIndices;
#define dealii__mesh_worker_loop_h
#include <deal.II/base/config.h>
-#include <deal.II/base/std_cxx11/function.h>
#include <deal.II/base/work_stream.h>
#include <deal.II/base/template_constraints.h>
#include <deal.II/grid/tria.h>
#include <deal.II/meshworker/dof_info.h>
#include <deal.II/meshworker/integration_info.h>
+#include <functional>
#define DEAL_II_MESHWORKER_PARALLEL 1
ITERATOR cell,
DoFInfoBox<dim, DOFINFO> &dof_info,
INFOBOX &info,
- const std_cxx11::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &cell_worker,
- const std_cxx11::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &boundary_worker,
- const std_cxx11::function<void (DOFINFO &, DOFINFO &,
- typename INFOBOX::CellInfo &,
- typename INFOBOX::CellInfo &)> &face_worker,
+ const std::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &cell_worker,
+ const std::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &boundary_worker,
+ const std::function<void (DOFINFO &, DOFINFO &,
+ typename INFOBOX::CellInfo &,
+ typename INFOBOX::CellInfo &)> &face_worker,
const LoopControl &loop_control)
{
const bool ignore_subdomain = (cell->get_triangulation().locally_owned_subdomain()
typename identity<ITERATOR>::type end,
DOFINFO &dinfo,
INFOBOX &info,
- const std_cxx11::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &cell_worker,
- const std_cxx11::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &boundary_worker,
- const std_cxx11::function<void (DOFINFO &, DOFINFO &,
- typename INFOBOX::CellInfo &,
- typename INFOBOX::CellInfo &)> &face_worker,
+ const std::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &cell_worker,
+ const std::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &boundary_worker,
+ const std::function<void (DOFINFO &, DOFINFO &,
+ typename INFOBOX::CellInfo &,
+ typename INFOBOX::CellInfo &)> &face_worker,
ASSEMBLER &assembler,
const LoopControl &lctrl = LoopControl())
{
// Loop over all cells
#ifdef DEAL_II_MESHWORKER_PARALLEL
WorkStream::run(begin, end,
- std_cxx11::bind(&cell_action<INFOBOX, DOFINFO, dim, spacedim, ITERATOR>,
- std_cxx11::_1, std_cxx11::_3, std_cxx11::_2,
- cell_worker, boundary_worker, face_worker, lctrl),
- std_cxx11::bind(&internal::assemble<dim,DOFINFO,ASSEMBLER>, std_cxx11::_1, &assembler),
+ std::bind(&cell_action<INFOBOX, DOFINFO, dim, spacedim, ITERATOR>,
+ std::placeholders::_1, std::placeholders::_3, std::placeholders::_2,
+ cell_worker, boundary_worker, face_worker, lctrl),
+ std::bind(&internal::assemble<dim,DOFINFO,ASSEMBLER>, std::placeholders::_1, &assembler),
info, dof_info);
#else
for (ITERATOR cell = begin; cell != end; ++cell)
ASSEMBLER &assembler,
const LoopControl &lctrl = LoopControl())
{
- std_cxx11::function<void (DoFInfo<dim>&, IntegrationInfo<dim, spacedim>&)> cell_worker;
- std_cxx11::function<void (DoFInfo<dim>&, IntegrationInfo<dim, spacedim>&)> boundary_worker;
- std_cxx11::function<void (DoFInfo<dim> &, DoFInfo<dim> &,
- IntegrationInfo<dim, spacedim> &,
- IntegrationInfo<dim, spacedim> &)> face_worker;
+ std::function<void (DoFInfo<dim>&, IntegrationInfo<dim, spacedim>&)> cell_worker;
+ std::function<void (DoFInfo<dim>&, IntegrationInfo<dim, spacedim>&)> boundary_worker;
+ std::function<void (DoFInfo<dim> &, DoFInfo<dim> &,
+ IntegrationInfo<dim, spacedim> &,
+ IntegrationInfo<dim, spacedim> &)> face_worker;
if (integrator.use_cell)
- cell_worker = std_cxx11::bind(&LocalIntegrator<dim, spacedim>::cell, &integrator, std_cxx11::_1, std_cxx11::_2);
+ cell_worker = std::bind(&LocalIntegrator<dim, spacedim>::cell, &integrator, std::placeholders::_1, std::placeholders::_2);
if (integrator.use_boundary)
- boundary_worker = std_cxx11::bind(&LocalIntegrator<dim, spacedim>::boundary, &integrator, std_cxx11::_1, std_cxx11::_2);
+ boundary_worker = std::bind(&LocalIntegrator<dim, spacedim>::boundary, &integrator, std::placeholders::_1, std::placeholders::_2);
if (integrator.use_face)
- face_worker = std_cxx11::bind(&LocalIntegrator<dim, spacedim>::face, &integrator, std_cxx11::_1, std_cxx11::_2, std_cxx11::_3, std_cxx11::_4);
+ face_worker = std::bind(&LocalIntegrator<dim, spacedim>::face, &integrator, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4);
loop<dim, spacedim>
(begin, end,
#include <deal.II/lac/sparse_matrix.h>
#include <deal.II/multigrid/mg_base.h>
#include <deal.II/base/mg_level_object.h>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
+
+#include <memory>
DEAL_II_NAMESPACE_OPEN
*/
std::size_t memory_consumption () const;
private:
- MGLevelObject<std
_cxx11::shared_ptr<PointerMatrixBase<VectorType> > > matrices;
+ MGLevelObject<std::shared_ptr<PointerMatrixBase<VectorType> > > matrices;
};
}
{
matrices.resize(p.min_level(), p.max_level());
for (unsigned int level=p.min_level(); level <= p.max_level(); ++level)
- matrices[level] = std
_cxx11::shared_ptr<PointerMatrixBase<VectorType> >
+ matrices[level] = std::shared_ptr<PointerMatrixBase<VectorType> >
(new_pointer_matrix_base(p[level], VectorType()));
}
#include <deal.II/dofs/dof_handler.h>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
+#include <memory>
DEAL_II_NAMESPACE_OPEN
/**
* Sparsity patterns for transfer matrices.
*/
- std::vector<std_cxx11::shared_ptr<typename internal::MatrixSelector<VectorType>::Sparsity> > prolongation_sparsities;
+ std::vector<std::shared_ptr<typename internal::MatrixSelector<VectorType>::Sparsity> > prolongation_sparsities;
/**
* The actual prolongation matrix. column indices belong to the dof indices
* of the mother cell, i.e. the coarse level. while row indices belong to
* the child cell, i.e. the fine level.
*/
- std::vector<std_cxx11::shared_ptr<typename internal::MatrixSelector<VectorType>::Matrix> > prolongation_matrices;
+ std::vector<std::shared_ptr<typename internal::MatrixSelector<VectorType>::Matrix> > prolongation_matrices;
/**
* Degrees of freedom on the refinement edge excluding those on the
#include <deal.II/dofs/dof_handler.h>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
+#include <memory>
DEAL_II_NAMESPACE_OPEN
DeclException0(ExcMatricesNotBuilt);
private:
- std::vector<std_cxx11::shared_ptr<BlockSparsityPattern> > prolongation_sparsities;
+ std::vector<std::shared_ptr<BlockSparsityPattern> > prolongation_sparsities;
protected:
* of the mother cell, i.e. the coarse level. while row indices belong to
* the child cell, i.e. the fine level.
*/
- std::vector<std_cxx11::shared_ptr<BlockSparseMatrix<double> > > prolongation_matrices;
+ std::vector<std::shared_ptr<BlockSparseMatrix<double> > > prolongation_matrices;
/**
* Mapping for the <tt>copy_to/from_mg</tt>-functions. The indices into this
#include <deal.II/base/config.h>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
#include <deal.II/lac/block_vector.h>
#include <deal.II/lac/constraint_matrix.h>
#include <deal.II/lac/sparsity_pattern.h>
#include <deal.II/fe/component_mask.h>
#include <deal.II/multigrid/mg_base.h>
+#include <memory>
+
DEAL_II_NAMESPACE_OPEN
DeclException0(ExcMatricesNotBuilt);
private:
- std::vector<std_cxx11::shared_ptr<BlockSparsityPattern> > prolongation_sparsities;
+ std::vector<std::shared_ptr<BlockSparsityPattern> > prolongation_sparsities;
protected:
* of the mother cell, i.e. the coarse level. while row indices belong to
* the child cell, i.e. the fine level.
*/
- std::vector<std_cxx11::shared_ptr<BlockSparseMatrix<double> > > prolongation_matrices;
+ std::vector<std::shared_ptr<BlockSparseMatrix<double> > > prolongation_matrices;
/**
* Holds the mapping for the <tt>copy_to/from_mg</tt>-functions. The data is
#include <deal.II/multigrid/mg_base.h>
#include <deal.II/multigrid/mg_tools.h>
#include <deal.II/base/mg_level_object.h>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
+
+#include <memory>
DEAL_II_NAMESPACE_OPEN
#include <deal.II/base/config.h>
#include <deal.II/numerics/data_out_dof_data.h>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
+#include <memory>
DEAL_II_NAMESPACE_OPEN
const unsigned int n_subdivisions,
const std::vector<unsigned int> &n_postprocessor_outputs,
const Mapping<dim,spacedim> &mapping,
- const std::vector<std_cxx11::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > &finite_elements,
+ const std::vector<std::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > &finite_elements,
const UpdateFlags update_flags,
const std::vector<std::vector<unsigned int> > &cell_to_patch_index_map);
#include <deal.II/numerics/data_postprocessor.h>
#include <deal.II/numerics/data_component_interpretation.h>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
+#include <memory>
DEAL_II_NAMESPACE_OPEN
const unsigned int n_subdivisions,
const std::vector<unsigned int> &n_postprocessor_outputs,
const Mapping<dim,spacedim> &mapping,
- const std::vector<std_cxx11::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > &finite_elements,
+ const std::vector<std::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > &finite_elements,
const UpdateFlags update_flags,
const bool use_face_values);
ParallelDataBase (const ParallelDataBase &data);
template <typename DoFHandlerType>
- void reinit_all_fe_values(std::vector<std_cxx11::shared_ptr<DataEntryBase<DoFHandlerType> > > &dof_data,
+ void reinit_all_fe_values(std::vector<std::shared_ptr<DataEntryBase<DoFHandlerType> > > &dof_data,
const typename dealii::Triangulation<dim,spacedim>::cell_iterator &cell,
const unsigned int face = numbers::invalid_unsigned_int);
std::vector<std::vector<dealii::Vector<double> > > postprocessed_values;
const dealii::hp::MappingCollection<dim,spacedim> mapping_collection;
- const std::vector<std_cxx11::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > finite_elements;
+ const std::vector<std::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > finite_elements;
const UpdateFlags update_flags;
- std::vector<std_cxx11::shared_ptr<dealii::hp::FEValues<dim,spacedim> > > x_fe_values;
- std::vector<std_cxx11::shared_ptr<dealii::hp::FEFaceValues<dim,spacedim> > > x_fe_face_values;
+ std::vector<std::shared_ptr<dealii::hp::FEValues<dim,spacedim> > > x_fe_values;
+ std::vector<std::shared_ptr<dealii::hp::FEFaceValues<dim,spacedim> > > x_fe_face_values;
};
}
}
/**
* List of data elements with vectors of values for each degree of freedom.
*/
- std::vector<std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DoFHandlerType> > > dof_data;
+ std::vector<std::shared_ptr<internal::DataOut::DataEntryBase<DoFHandlerType> > > dof_data;
/**
* List of data elements with vectors of values for each cell.
*/
- std::vector<std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DoFHandlerType> > > cell_data;
+ std::vector<std::shared_ptr<internal::DataOut::DataEntryBase<DoFHandlerType> > > cell_data;
/**
* This is a list of patches that is created each time build_patches() is
* Extracts the finite elements stored in the dof_data object, including a
* dummy object of FE_DGQ<dim>(0) in case only the triangulation is used.
*/
- std::vector<std_cxx11::shared_ptr<dealii::hp::FECollection<DoFHandlerType::dimension,DoFHandlerType::space_dimension> > >
+ std::vector<std::shared_ptr<dealii::hp::FECollection<DoFHandlerType::dimension,DoFHandlerType::space_dimension> > >
get_finite_elements() const;
/**
* function. See there for a more extensive documentation.
*/
virtual
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> >
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> >
get_vector_data_ranges () const;
/**
"as vectors."));
for (unsigned int i=0; i<get_vector_data_ranges().size(); ++i)
{
- Assert (std_cxx11::get<0>(get_vector_data_ranges()[i]) ==
- std_cxx11::get<0>(source.get_vector_data_ranges()[i]),
+ Assert (std::get<0>(get_vector_data_ranges()[i]) ==
+ std::get<0>(source.get_vector_data_ranges()[i]),
ExcMessage ("Both sources need to declare the same components "
"as vectors."));
- Assert (std_cxx11::get<1>(get_vector_data_ranges()[i]) ==
- std_cxx11::get<1>(source.get_vector_data_ranges()[i]),
+ Assert (std::get<1>(get_vector_data_ranges()[i]) ==
+ std::get<1>(source.get_vector_data_ranges()[i]),
ExcMessage ("Both sources need to declare the same components "
"as vectors."));
- Assert (std_cxx11::get<2>(get_vector_data_ranges()[i]) ==
- std_cxx11::get<2>(source.get_vector_data_ranges()[i]),
+ Assert (std::get<2>(get_vector_data_ranges()[i]) ==
+ std::get<2>(source.get_vector_data_ranges()[i]),
ExcMessage ("Both sources need to declare the same components "
"as vectors."));
}
const unsigned int n_subdivisions,
const std::vector<unsigned int> &n_postprocessor_outputs,
const Mapping<dim,spacedim> &mapping,
- const std::vector<std_cxx11::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > &finite_elements,
+ const std::vector<std::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > &finite_elements,
const UpdateFlags update_flags);
std::vector<Point<spacedim> > patch_evaluation_points;
const unsigned int n_patches_per_circle,
const std::vector<unsigned int> &n_postprocessor_outputs,
const Mapping<dim,spacedim> &mapping,
- const std::vector<std_cxx11::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > &finite_elements,
+ const std::vector<std::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > &finite_elements,
const UpdateFlags update_flags);
const unsigned int n_patches_per_circle;
#include <deal.II/base/config.h>
#include <deal.II/base/exceptions.h>
-#include <deal.II/base/std_cxx11/tuple.h>
#include <deal.II/base/synchronous_iterator.h>
#include <deal.II/fe/fe_update_flags.h>
#include <deal.II/fe/mapping.h>
#include <deal.II/numerics/error_estimator.h>
#include <deal.II/distributed/tria.h>
-#include <deal.II/base/std_cxx11/bind.h>
#include <numeric>
#include <algorithm>
#include <cmath>
#include <vector>
+#include <functional>
DEAL_II_NAMESPACE_OPEN
// now let's work on all those cells:
WorkStream::run (dof_handler.begin_active(),
static_cast<typename DoFHandlerType::active_cell_iterator>(dof_handler.end()),
- std_cxx11::bind (&internal::estimate_one_cell<InputVector,DoFHandlerType>,
- std_cxx11::_1, std_cxx11::_2, std_cxx11::_3, std_cxx11::ref(solutions),strategy),
- std_cxx11::bind (&internal::copy_local_to_global<DoFHandlerType>,
- std_cxx11::_1, std_cxx11::ref(face_integrals)),
+ std::bind (&internal::estimate_one_cell<InputVector,DoFHandlerType>,
+ std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::ref(solutions),strategy),
+ std::bind (&internal::copy_local_to_global<DoFHandlerType>,
+ std::placeholders::_1, std::ref(face_integrals)),
parallel_data,
sample_local_face_integrals);
WorkStream::run (dof.begin_active(),
static_cast<typename DoFHandler<dim,spacedim>::active_cell_iterator>(dof.end()),
&MatrixCreator::internal::mass_assembler<dim, spacedim, typename DoFHandler<dim,spacedim>::active_cell_iterator,number>,
- std_cxx11::bind (&MatrixCreator::internal::
- copy_local_to_global<number,SparseMatrix<number>, Vector<number> >,
- std_cxx11::_1, &matrix, (Vector<number> *)0),
+ std::bind (&MatrixCreator::internal::
+ copy_local_to_global<number,SparseMatrix<number>, Vector<number> >,
+ std::placeholders::_1, &matrix, (Vector<number> *)0),
assembler_data,
copy_data);
}
WorkStream::run (dof.begin_active(),
static_cast<typename DoFHandler<dim,spacedim>::active_cell_iterator>(dof.end()),
&MatrixCreator::internal::mass_assembler<dim, spacedim, typename DoFHandler<dim,spacedim>::active_cell_iterator,number>,
- std_cxx11::bind(&MatrixCreator::internal::
- copy_local_to_global<number,SparseMatrix<number>, Vector<number> >,
- std_cxx11::_1, &matrix, &rhs_vector),
+ std::bind(&MatrixCreator::internal::
+ copy_local_to_global<number,SparseMatrix<number>, Vector<number> >,
+ std::placeholders::_1, &matrix, &rhs_vector),
assembler_data,
copy_data);
}
WorkStream::run (dof.begin_active(),
static_cast<typename hp::DoFHandler<dim,spacedim>::active_cell_iterator>(dof.end()),
&MatrixCreator::internal::mass_assembler<dim, spacedim, typename hp::DoFHandler<dim,spacedim>::active_cell_iterator,number>,
- std_cxx11::bind (&MatrixCreator::internal::
- copy_local_to_global<number,SparseMatrix<number>, Vector<number> >,
- std_cxx11::_1, &matrix, (Vector<number> *)0),
+ std::bind (&MatrixCreator::internal::
+ copy_local_to_global<number,SparseMatrix<number>, Vector<number> >,
+ std::placeholders::_1, &matrix, (Vector<number> *)0),
assembler_data,
copy_data);
}
WorkStream::run (dof.begin_active(),
static_cast<typename hp::DoFHandler<dim,spacedim>::active_cell_iterator>(dof.end()),
&MatrixCreator::internal::mass_assembler<dim, spacedim, typename hp::DoFHandler<dim,spacedim>::active_cell_iterator,number>,
- std_cxx11::bind (&MatrixCreator::internal::
- copy_local_to_global<number,SparseMatrix<number>, Vector<number> >,
- std_cxx11::_1, &matrix, &rhs_vector),
+ std::bind (&MatrixCreator::internal::
+ copy_local_to_global<number,SparseMatrix<number>, Vector<number> >,
+ std::placeholders::_1, &matrix, &rhs_vector),
assembler_data,
copy_data);
}
MatrixCreator::internal::AssemblerBoundary::CopyData<DoFHandler<dim,spacedim>,number > copy_data;
WorkStream::run(dof.begin_active(),dof.end(),
- static_cast<std_cxx11::function<void (typename DoFHandler<dim,spacedim>::active_cell_iterator
- const &,MatrixCreator::internal::AssemblerBoundary::Scratch const &,
- MatrixCreator::internal::AssemblerBoundary::CopyData<DoFHandler<dim,spacedim>,number > &)> >
- (std_cxx11::bind(&internal::create_boundary_mass_matrix_1<dim,spacedim,number>,std_cxx11::_1,std_cxx11::_2,
- std_cxx11::_3,
- std_cxx11::cref(mapping),std_cxx11::cref(fe),std_cxx11::cref(q),
- std_cxx11::cref(boundary_functions),coefficient,
- std_cxx11::cref(component_mapping))),
- static_cast<std_cxx11::function<void (MatrixCreator::internal::AssemblerBoundary
- ::CopyData<DoFHandler<dim,spacedim>,number> const &)> > (std_cxx11::bind(
- &internal::copy_boundary_mass_matrix_1<dim,spacedim,number>,
- std_cxx11::_1,
- std_cxx11::cref(boundary_functions),
- std_cxx11::cref(dof_to_boundary_mapping),
- std_cxx11::ref(matrix),
- std_cxx11::ref(rhs_vector))),
+ static_cast<std::function<void (typename DoFHandler<dim,spacedim>::active_cell_iterator
+ const &,MatrixCreator::internal::AssemblerBoundary::Scratch const &,
+ MatrixCreator::internal::AssemblerBoundary::CopyData<DoFHandler<dim,spacedim>,number > &)> >
+ (std::bind(&internal::create_boundary_mass_matrix_1<dim,spacedim,number>,std::placeholders::_1,std::placeholders::_2,
+ std::placeholders::_3,
+ std::cref(mapping),std::cref(fe),std::cref(q),
+ std::cref(boundary_functions),coefficient,
+ std::cref(component_mapping))),
+ static_cast<std::function<void (MatrixCreator::internal::AssemblerBoundary
+ ::CopyData<DoFHandler<dim,spacedim>,number> const &)> > (std::bind(
+ &internal::copy_boundary_mass_matrix_1<dim,spacedim,number>,
+ std::placeholders::_1,
+ std::cref(boundary_functions),
+ std::cref(dof_to_boundary_mapping),
+ std::ref(matrix),
+ std::ref(rhs_vector))),
scratch,
copy_data);
}
MatrixCreator::internal::AssemblerBoundary::CopyData<hp::DoFHandler<dim,spacedim>,number > copy_data;
WorkStream::run(dof.begin_active(),dof.end(),
- static_cast<std_cxx11::function<void (typename hp::DoFHandler<dim,spacedim>::active_cell_iterator
- const &,MatrixCreator::internal::AssemblerBoundary::Scratch const &,
- MatrixCreator::internal::AssemblerBoundary::CopyData<hp::DoFHandler<dim,spacedim>,number > &)> >
- (std_cxx11::bind( &create_hp_boundary_mass_matrix_1<dim,spacedim,number>,std_cxx11::_1,std_cxx11::_2,
- std_cxx11::_3,
- std_cxx11::cref(mapping),std_cxx11::cref(fe_collection),std_cxx11::cref(q),
- std_cxx11::cref(boundary_functions),coefficient,
- std_cxx11::cref(component_mapping))),
- static_cast<std_cxx11::function<void (MatrixCreator::internal::AssemblerBoundary
- ::CopyData<hp::DoFHandler<dim,spacedim>,number > const &)> > (
- std_cxx11::bind( ©_hp_boundary_mass_matrix_1<dim,spacedim,number>,
- std_cxx11::_1,
- std_cxx11::cref(boundary_functions),
- std_cxx11::cref(dof_to_boundary_mapping),
- std_cxx11::ref(matrix),
- std_cxx11::ref(rhs_vector))),
+ static_cast<std::function<void (typename hp::DoFHandler<dim,spacedim>::active_cell_iterator
+ const &,MatrixCreator::internal::AssemblerBoundary::Scratch const &,
+ MatrixCreator::internal::AssemblerBoundary::CopyData<hp::DoFHandler<dim,spacedim>,number > &)> >
+ (std::bind( &create_hp_boundary_mass_matrix_1<dim,spacedim,number>,std::placeholders::_1,std::placeholders::_2,
+ std::placeholders::_3,
+ std::cref(mapping),std::cref(fe_collection),std::cref(q),
+ std::cref(boundary_functions),coefficient,
+ std::cref(component_mapping))),
+ static_cast<std::function<void (MatrixCreator::internal::AssemblerBoundary
+ ::CopyData<hp::DoFHandler<dim,spacedim>,number > const &)> > (
+ std::bind( ©_hp_boundary_mass_matrix_1<dim,spacedim,number>,
+ std::placeholders::_1,
+ std::cref(boundary_functions),
+ std::cref(dof_to_boundary_mapping),
+ std::ref(matrix),
+ std::ref(rhs_vector))),
scratch,
copy_data);
}
WorkStream::run (dof.begin_active(),
static_cast<typename DoFHandler<dim,spacedim>::active_cell_iterator>(dof.end()),
&MatrixCreator::internal::laplace_assembler<dim, spacedim, typename DoFHandler<dim,spacedim>::active_cell_iterator>,
- std_cxx11::bind (&MatrixCreator::internal::
- copy_local_to_global<double,SparseMatrix<double>, Vector<double> >,
- std_cxx11::_1,
- &matrix,
- (Vector<double> *)NULL),
+ std::bind (&MatrixCreator::internal::
+ copy_local_to_global<double,SparseMatrix<double>, Vector<double> >,
+ std::placeholders::_1,
+ &matrix,
+ (Vector<double> *)NULL),
assembler_data,
copy_data);
}
WorkStream::run (dof.begin_active(),
static_cast<typename DoFHandler<dim,spacedim>::active_cell_iterator>(dof.end()),
&MatrixCreator::internal::laplace_assembler<dim, spacedim, typename DoFHandler<dim,spacedim>::active_cell_iterator>,
- std_cxx11::bind (&MatrixCreator::internal::
- copy_local_to_global<double,SparseMatrix<double>, Vector<double> >,
- std_cxx11::_1,
- &matrix,
- &rhs_vector),
+ std::bind (&MatrixCreator::internal::
+ copy_local_to_global<double,SparseMatrix<double>, Vector<double> >,
+ std::placeholders::_1,
+ &matrix,
+ &rhs_vector),
assembler_data,
copy_data);
}
WorkStream::run (dof.begin_active(),
static_cast<typename hp::DoFHandler<dim,spacedim>::active_cell_iterator>(dof.end()),
&MatrixCreator::internal::laplace_assembler<dim, spacedim, typename hp::DoFHandler<dim,spacedim>::active_cell_iterator>,
- std_cxx11::bind (&MatrixCreator::internal::
- copy_local_to_global<double,SparseMatrix<double>, Vector<double> >,
- std_cxx11::_1,
- &matrix,
- (Vector<double> *)0),
+ std::bind (&MatrixCreator::internal::
+ copy_local_to_global<double,SparseMatrix<double>, Vector<double> >,
+ std::placeholders::_1,
+ &matrix,
+ (Vector<double> *)0),
assembler_data,
copy_data);
}
WorkStream::run (dof.begin_active(),
static_cast<typename hp::DoFHandler<dim,spacedim>::active_cell_iterator>(dof.end()),
&MatrixCreator::internal::laplace_assembler<dim, spacedim, typename hp::DoFHandler<dim,spacedim>::active_cell_iterator>,
- std_cxx11::bind (&MatrixCreator::internal::
- copy_local_to_global<double,SparseMatrix<double>, Vector<double> >,
- std_cxx11::_1,
- &matrix,
- &rhs_vector),
+ std::bind (&MatrixCreator::internal::
+ copy_local_to_global<double,SparseMatrix<double>, Vector<double> >,
+ std::placeholders::_1,
+ &matrix,
+ &rhs_vector),
assembler_data,
copy_data);
}
* void
* TimeDependent::solve_primal_problem ()
* {
- * do_loop (std_cxx11::bind(&TimeStepBase::init_for_primal_problem, std_cxx11::_1),
- * std_cxx11::bind(&TimeStepBase::solve_primal_problem, std_cxx11::_1),
+ * do_loop (std::bind(&TimeStepBase::init_for_primal_problem, std::placeholders::_1),
+ * std::bind(&TimeStepBase::solve_primal_problem, std::placeholders::_1),
* timestepping_data_primal,
* forward);
* };
* look-back and the last one denotes in which direction the loop is to be
* run.
*
- * Using function pointers through the @p std_cxx11::bind functions provided by the
+ * Using function pointers through the @p std::bind functions provided by the
* <tt>C++</tt> standard library, it is possible to do neat tricks, like the
* following, also taken from the wave program, in this case from the function
* @p refine_grids:
* compute the thresholds for refinement
* ...
*
- * do_loop (std_cxx11::bind(&TimeStepBase_Tria<dim>::init_for_refinement, std_cxx11::_1),
- * std_cxx11::bind(&TimeStepBase_Wave<dim>::refine_grid,
- * std_cxx11::_1,
- * TimeStepBase_Tria<dim>::RefinementData (top_threshold,
- * bottom_threshold)),
+ * do_loop (std::bind(&TimeStepBase_Tria<dim>::init_for_refinement, std::placeholders::_1),
+ * std::bind(&TimeStepBase_Wave<dim>::refine_grid,
+ * std::placeholders::_1,
+ * TimeStepBase_Tria<dim>::RefinementData (top_threshold,
+ * bottom_threshold)),
* TimeDependent::TimeSteppingData (0,1),
* TimeDependent::forward);
* @endcode
*
* To see how this function work, note that the function @p
* solve_primal_problem only consists of a call to <tt>do_loop
- * (std_cxx11::bind(&TimeStepBase::init_for_primal_problem, std_cxx11::_1),
- * std_cxx11::bind(&TimeStepBase::solve_primal_problem, std_cxx11::_1), timestepping_data_primal,
+ * (std::bind(&TimeStepBase::init_for_primal_problem, std::placeholders::_1),
+ * std::bind(&TimeStepBase::solve_primal_problem, std::placeholders::_1), timestepping_data_primal,
* forward);</tt>.
*
* Note also, that the given class from which the two functions are taken
* the TimeStepBase class.
*
* Instead of using the above form, you can equally well use
- * <tt>std_cxx11::bind(&X::unary_function, std_cxx11::_1, args...)</tt> which
+ * <tt>std::bind(&X::unary_function, std::placeholders::_1, args...)</tt> which
* lets the @p do_loop function call the given function with the specified
* parameters.
*/
#include <deal.II/base/exceptions.h>
#include <deal.II/base/quadrature_lib.h>
#include <deal.II/base/point.h>
-#include <deal.II/base/std_cxx11/function.h>
#include <deal.II/dofs/function_map.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/hp/dof_handler.h>
#include <map>
#include <vector>
#include <set>
+#include <functional>
DEAL_II_NAMESPACE_OPEN
const DoFHandler<dim,spacedim> &dof,
const ConstraintMatrix &constraints,
const Quadrature<dim> &quadrature,
- const std_cxx11::function< typename VectorType::value_type (const typename DoFHandler<dim, spacedim>::active_cell_iterator &, const unsigned int)> func,
+ const std::function< typename VectorType::value_type (const typename DoFHandler<dim, spacedim>::active_cell_iterator &, const unsigned int)> func,
VectorType &vec_result);
/**
* which stores quadrature point data.
*/
template <int dim, typename VectorType>
- void project (std_cxx11::shared_ptr<const MatrixFree<dim,typename VectorType::value_type> > data,
+ void project (std::shared_ptr<const MatrixFree<dim,typename VectorType::value_type> > data,
const ConstraintMatrix &constraints,
const unsigned int n_q_points_1d,
- const std_cxx11::function< VectorizedArray<typename VectorType::value_type> (const unsigned int, const unsigned int)> func,
+ const std::function< VectorizedArray<typename VectorType::value_type> (const unsigned int, const unsigned int)> func,
VectorType &vec_result);
/**
* Same as above but for <code>n_q_points_1d = matrix_free.get_dof_handler().get_fe().degree+1</code>.
*/
template <int dim, typename VectorType>
- void project (std_cxx11::shared_ptr<const MatrixFree<dim,typename VectorType::value_type> > data,
+ void project (std::shared_ptr<const MatrixFree<dim,typename VectorType::value_type> > data,
const ConstraintMatrix &constraints,
- const std_cxx11::function< VectorizedArray<typename VectorType::value_type> (const unsigned int, const unsigned int)> func,
+ const std::function< VectorizedArray<typename VectorType::value_type> (const unsigned int, const unsigned int)> func,
VectorType &vec_result);
/**
#include <deal.II/numerics/vector_tools.h>
#include <deal.II/numerics/matrix_tools.h>
-#include <deal.II/base/std_cxx11/array.h>
+#include <array>
#include <numeric>
#include <algorithm>
#include <vector>
additional_data.tasks_parallel_scheme =
MatrixFree<dim,Number>::AdditionalData::partition_color;
additional_data.mapping_update_flags = (update_values | update_JxW_values);
- std_cxx11::shared_ptr<MatrixFree<dim, Number> > matrix_free(
+ std::shared_ptr<MatrixFree<dim, Number> > matrix_free(
new MatrixFree<dim, Number> ());
matrix_free->reinit (mapping, dof, constraints,
QGauss<1>(dof.get_fe().degree+2), additional_data);
const DoFHandler<dim,spacedim> &dof,
const ConstraintMatrix &constraints,
const Quadrature<dim> &quadrature,
- const std_cxx11::function< typename VectorType::value_type (const typename DoFHandler<dim, spacedim>::active_cell_iterator &, const unsigned int)> func,
+ const std::function< typename VectorType::value_type (const typename DoFHandler<dim, spacedim>::active_cell_iterator &, const unsigned int)> func,
VectorType &vec_result)
{
typedef typename VectorType::value_type Number;
additional_data.tasks_parallel_scheme =
MatrixFree<dim,Number>::AdditionalData::partition_color;
additional_data.mapping_update_flags = (update_values | update_JxW_values);
- std_cxx11::shared_ptr<MatrixFree<dim, Number> > matrix_free(
+ std::shared_ptr<MatrixFree<dim, Number> > matrix_free(
new MatrixFree<dim, Number>());
matrix_free->reinit (mapping, dof, constraints,
QGauss<1>(dof.get_fe().degree+2), additional_data);
template <int dim, typename VectorType, int spacedim, int fe_degree, int n_q_points_1d>
- void project_parallel (std_cxx11::shared_ptr<const MatrixFree<dim,typename VectorType::value_type> > matrix_free,
+ void project_parallel (std::shared_ptr<const MatrixFree<dim,typename VectorType::value_type> > matrix_free,
const ConstraintMatrix &constraints,
- const std_cxx11::function< VectorizedArray<typename VectorType::value_type> (const unsigned int, const unsigned int)> func,
+ const std::function< VectorizedArray<typename VectorType::value_type> (const unsigned int, const unsigned int)> func,
VectorType &vec_result)
{
const DoFHandler<dim,spacedim> &dof = matrix_free->get_dof_handler();
const DoFHandler<dim,spacedim> &dof,
const ConstraintMatrix &constraints,
const Quadrature<dim> &quadrature,
- const std_cxx11::function< typename VectorType::value_type (const typename DoFHandler<dim, spacedim>::active_cell_iterator &, const unsigned int)> func,
+ const std::function< typename VectorType::value_type (const typename DoFHandler<dim, spacedim>::active_cell_iterator &, const unsigned int)> func,
VectorType &vec_result)
{
switch (dof.get_fe().degree)
template <int dim, typename VectorType>
- void project (std_cxx11::shared_ptr<const MatrixFree<dim,typename VectorType::value_type> > matrix_free,
+ void project (std::shared_ptr<const MatrixFree<dim,typename VectorType::value_type> > matrix_free,
const ConstraintMatrix &constraints,
const unsigned int n_q_points_1d,
- const std_cxx11::function< VectorizedArray<typename VectorType::value_type> (const unsigned int, const unsigned int)> func,
+ const std::function< VectorizedArray<typename VectorType::value_type> (const unsigned int, const unsigned int)> func,
VectorType &vec_result)
{
(void) n_q_points_1d;
template <int dim, typename VectorType>
- void project (std_cxx11::shared_ptr<const MatrixFree<dim,typename VectorType::value_type> > matrix_free,
+ void project (std::shared_ptr<const MatrixFree<dim,typename VectorType::value_type> > matrix_free,
const ConstraintMatrix &constraints,
- const std_cxx11::function< VectorizedArray<typename VectorType::value_type> (const unsigned int, const unsigned int)> func,
+ const std::function< VectorizedArray<typename VectorType::value_type> (const unsigned int, const unsigned int)> func,
VectorType &vec_result)
{
project (matrix_free,
template <int dim>
struct PointComparator
{
- bool operator ()(const std_cxx11::array<types::global_dof_index,dim> &p1,
- const std_cxx11::array<types::global_dof_index,dim> &p2)
+ bool operator ()(const std::array<types::global_dof_index,dim> &p1,
+ const std::array<types::global_dof_index,dim> &p2)
{
for (unsigned int d=0; d<dim; ++d)
if (p1[d] < p2[d])
// Extract a list that collects all vector components that belong to the
// same node (scalar basis function). When creating that list, we use an
// array of dim components that stores the global degree of freedom.
- std::set<std_cxx11::array<types::global_dof_index,dim>, PointComparator<dim> > vector_dofs;
+ std::set<std::array<types::global_dof_index,dim>, PointComparator<dim> > vector_dofs;
std::vector<types::global_dof_index> face_dofs;
- std::map<std_cxx11::array<types::global_dof_index,dim>, Vector<double> >
+ std::map<std::array<types::global_dof_index,dim>, Vector<double> >
dof_vector_to_b_values;
std::set<types::boundary_id>::iterator b_id;
- std::vector<std_cxx11::array<types::global_dof_index,dim> > cell_vector_dofs;
+ std::vector<std::array<types::global_dof_index,dim> > cell_vector_dofs;
for (typename DoFHandlerType<dim,spacedim>::active_cell_iterator cell =
dof_handler.begin_active(); cell != dof_handler.end(); ++cell)
if (!cell->is_artificial())
// iterate over the list of all vector components we found and see if we
// can find constrained ones
unsigned int n_total_constraints_found = 0;
- for (typename std::set<std_cxx11::array<types::global_dof_index,dim>,
+ for (typename std::set<std::array<types::global_dof_index,dim>,
PointComparator<dim> >::const_iterator it=vector_dofs.begin();
it!=vector_dofs.end(); ++it)
{
* Return a tuple representing the minimum and maximum values of u
* and v. Precisely, it returns (u_min, u_max, v_min, v_max)
*/
- std_cxx11::tuple<double, double, double, double>
+ std::tuple<double, double, double, double>
get_uv_bounds() const;
/**
* associated with actual geometries) which are contained in the given
* shape.
*/
- std_cxx11::tuple<unsigned int, unsigned int, unsigned int>
+ std::tuple<unsigned int, unsigned int, unsigned int>
count_elements(const TopoDS_Shape &shape);
/**
* the u coordinate and the v coordinate (which is different from zero only
* if the resulting shape is a face).
*/
- std
_cxx11::tuple<Point<3>, TopoDS_Shape, double, double>
+ std::tuple<Point<3>, TopoDS_Shape, double, double>
project_point_and_pull_back(const TopoDS_Shape &in_shape,
const Point<3> &origin,
const double tolerance=1e-7);
* face, returns the corresponding point in real space, the normal to the
* surface at that point and the min and max curvatures as a tuple.
*/
- std
_cxx11::tuple<Point<3>, Tensor<1,3>, double, double>
+ std::tuple<Point<3>, Tensor<1,3>, double, double>
push_forward_and_differential_forms(const TopoDS_Face &face,
const double u,
const double v,
* and only the closest point is returned. This function will throw an
* exception if the @p in_shape does not contain at least one face.
*/
- std
_cxx11::tuple<Point<3>, Tensor<1,3>, double, double>
+ std::tuple<Point<3>, Tensor<1,3>, double, double>
closest_point_and_differential_forms(const TopoDS_Shape &in_shape,
const Point<3> &origin,
const double tolerance=1e-7);
#include <deal.II/base/parameter_handler.h>
#include <deal.II/base/thread_management.h>
#include <deal.II/base/memory_consumption.h>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
#include <deal.II/base/mpi.h>
#include <cstring>
#include <set>
#include <sstream>
#include <fstream>
+#include <memory>
// we use uint32_t and uint8_t below, which are declared here:
#include <stdint.h>
template <int dim, int spacedim>
void write_ucd (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &,
const UcdFlags &flags,
std::ostream &out)
{
template <int dim, int spacedim>
void write_dx (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &,
const DXFlags &flags,
std::ostream &out)
{
template <int dim, int spacedim>
void write_gnuplot (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &,
const GnuplotFlags &flags,
std::ostream &out)
{
template <int dim, int spacedim>
void write_povray (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &,
const PovrayFlags &flags,
std::ostream &out)
{
template <int dim, int spacedim>
void write_eps (const std::vector<Patch<dim,spacedim> > &/*patches*/,
const std::vector<std::string> &/*data_names*/,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &,
const EpsFlags &/*flags*/,
std::ostream &/*out*/)
{
template <int spacedim>
void write_eps (const std::vector<Patch<2,spacedim> > &patches,
const std::vector<std::string> &/*data_names*/,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &,
const EpsFlags &flags,
std::ostream &out)
{
template <int dim, int spacedim>
void write_gmv (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &,
const GmvFlags &flags,
std::ostream &out)
{
template <int dim, int spacedim>
void write_tecplot (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &,
const TecplotFlags &flags,
std::ostream &out)
{
template <int dim, int spacedim>
void write_tecplot_binary (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const TecplotFlags &flags,
std::ostream &out)
{
void
write_vtk (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const VtkFlags &flags,
std::ostream &out)
{
std::vector<bool> data_set_written (n_data_sets, false);
for (unsigned int n_th_vector=0; n_th_vector<vector_data_ranges.size(); ++n_th_vector)
{
- AssertThrow (std_cxx11::get<1>(vector_data_ranges[n_th_vector]) >=
- std_cxx11::get<0>(vector_data_ranges[n_th_vector]),
- ExcLowerRange (std_cxx11::get<1>(vector_data_ranges[n_th_vector]),
- std_cxx11::get<0>(vector_data_ranges[n_th_vector])));
- AssertThrow (std_cxx11::get<1>(vector_data_ranges[n_th_vector]) < n_data_sets,
- ExcIndexRange (std_cxx11::get<1>(vector_data_ranges[n_th_vector]),
+ AssertThrow (std::get<1>(vector_data_ranges[n_th_vector]) >=
+ std::get<0>(vector_data_ranges[n_th_vector]),
+ ExcLowerRange (std::get<1>(vector_data_ranges[n_th_vector]),
+ std::get<0>(vector_data_ranges[n_th_vector])));
+ AssertThrow (std::get<1>(vector_data_ranges[n_th_vector]) < n_data_sets,
+ ExcIndexRange (std::get<1>(vector_data_ranges[n_th_vector]),
0, n_data_sets));
- AssertThrow (std_cxx11::get<1>(vector_data_ranges[n_th_vector]) + 1
- - std_cxx11::get<0>(vector_data_ranges[n_th_vector]) <= 3,
+ AssertThrow (std::get<1>(vector_data_ranges[n_th_vector]) + 1
+ - std::get<0>(vector_data_ranges[n_th_vector]) <= 3,
ExcMessage ("Can't declare a vector with more than 3 components "
"in VTK"));
// mark these components as already written:
- for (unsigned int i=std_cxx11::get<0>(vector_data_ranges[n_th_vector]);
- i<=std_cxx11::get<1>(vector_data_ranges[n_th_vector]);
+ for (unsigned int i=std::get<0>(vector_data_ranges[n_th_vector]);
+ i<=std::get<1>(vector_data_ranges[n_th_vector]);
++i)
data_set_written[i] = true;
// name has been specified
out << "VECTORS ";
- if (std_cxx11::get<2>(vector_data_ranges[n_th_vector]) != "")
- out << std_cxx11::get<2>(vector_data_ranges[n_th_vector]);
+ if (std::get<2>(vector_data_ranges[n_th_vector]) != "")
+ out << std::get<2>(vector_data_ranges[n_th_vector]);
else
{
- for (unsigned int i=std_cxx11::get<0>(vector_data_ranges[n_th_vector]);
- i<std_cxx11::get<1>(vector_data_ranges[n_th_vector]);
+ for (unsigned int i=std::get<0>(vector_data_ranges[n_th_vector]);
+ i<std::get<1>(vector_data_ranges[n_th_vector]);
++i)
out << data_names[i] << "__";
- out << data_names[std_cxx11::get<1>(vector_data_ranges[n_th_vector])];
+ out << data_names[std::get<1>(vector_data_ranges[n_th_vector])];
}
out << " double"
// components
for (unsigned int n=0; n<n_nodes; ++n)
{
- switch (std_cxx11::get<1>(vector_data_ranges[n_th_vector]) -
- std_cxx11::get<0>(vector_data_ranges[n_th_vector]))
+ switch (std::get<1>(vector_data_ranges[n_th_vector]) -
+ std::get<0>(vector_data_ranges[n_th_vector]))
{
case 0:
- out << data_vectors(std_cxx11::get<0>(vector_data_ranges[n_th_vector]), n) << " 0 0"
+ out << data_vectors(std::get<0>(vector_data_ranges[n_th_vector]), n) << " 0 0"
<< '\n';
break;
case 1:
- out << data_vectors(std_cxx11::get<0>(vector_data_ranges[n_th_vector]), n) << ' '<< data_vectors(std_cxx11::get<0>(vector_data_ranges[n_th_vector])+1, n) << " 0"
+ out << data_vectors(std::get<0>(vector_data_ranges[n_th_vector]), n) << ' '<< data_vectors(std::get<0>(vector_data_ranges[n_th_vector])+1, n) << " 0"
<< '\n';
break;
case 2:
- out << data_vectors(std_cxx11::get<0>(vector_data_ranges[n_th_vector]), n) << ' '<< data_vectors(std_cxx11::get<0>(vector_data_ranges[n_th_vector])+1, n) << ' '<< data_vectors(std_cxx11::get<0>(vector_data_ranges[n_th_vector])+2, n)
+ out << data_vectors(std::get<0>(vector_data_ranges[n_th_vector]), n) << ' '<< data_vectors(std::get<0>(vector_data_ranges[n_th_vector])+1, n) << ' '<< data_vectors(std::get<0>(vector_data_ranges[n_th_vector])+2, n)
<< '\n';
break;
void
write_vtu (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const VtkFlags &flags,
std::ostream &out)
{
template <int dim, int spacedim>
void write_vtu_main (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const VtkFlags &flags,
std::ostream &out)
{
{
// mark these components as already
// written:
- for (unsigned int i=std_cxx11::get<0>(vector_data_ranges[n_th_vector]);
- i<=std_cxx11::get<1>(vector_data_ranges[n_th_vector]);
+ for (unsigned int i=std::get<0>(vector_data_ranges[n_th_vector]);
+ i<=std::get<1>(vector_data_ranges[n_th_vector]);
++i)
data_set_written[i] = true;
// name has been specified
out << " <DataArray type=\"Float64\" Name=\"";
- if (std_cxx11::get<2>(vector_data_ranges[n_th_vector]) != "")
- out << std_cxx11::get<2>(vector_data_ranges[n_th_vector]);
+ if (std::get<2>(vector_data_ranges[n_th_vector]) != "")
+ out << std::get<2>(vector_data_ranges[n_th_vector]);
else
{
- for (unsigned int i=std_cxx11::get<0>(vector_data_ranges[n_th_vector]);
- i<std_cxx11::get<1>(vector_data_ranges[n_th_vector]);
+ for (unsigned int i=std::get<0>(vector_data_ranges[n_th_vector]);
+ i<std::get<1>(vector_data_ranges[n_th_vector]);
++i)
out << data_names[i] << "__";
- out << data_names[std_cxx11::get<1>(vector_data_ranges[n_th_vector])];
+ out << data_names[std::get<1>(vector_data_ranges[n_th_vector])];
}
out << "\" NumberOfComponents=\"3\"></DataArray>\n";
std::vector<bool> data_set_written (n_data_sets, false);
for (unsigned int n_th_vector=0; n_th_vector<vector_data_ranges.size(); ++n_th_vector)
{
- AssertThrow (std_cxx11::get<1>(vector_data_ranges[n_th_vector]) >=
- std_cxx11::get<0>(vector_data_ranges[n_th_vector]),
- ExcLowerRange (std_cxx11::get<1>(vector_data_ranges[n_th_vector]),
- std_cxx11::get<0>(vector_data_ranges[n_th_vector])));
- AssertThrow (std_cxx11::get<1>(vector_data_ranges[n_th_vector]) < n_data_sets,
- ExcIndexRange (std_cxx11::get<1>(vector_data_ranges[n_th_vector]),
+ AssertThrow (std::get<1>(vector_data_ranges[n_th_vector]) >=
+ std::get<0>(vector_data_ranges[n_th_vector]),
+ ExcLowerRange (std::get<1>(vector_data_ranges[n_th_vector]),
+ std::get<0>(vector_data_ranges[n_th_vector])));
+ AssertThrow (std::get<1>(vector_data_ranges[n_th_vector]) < n_data_sets,
+ ExcIndexRange (std::get<1>(vector_data_ranges[n_th_vector]),
0, n_data_sets));
- AssertThrow (std_cxx11::get<1>(vector_data_ranges[n_th_vector]) + 1
- - std_cxx11::get<0>(vector_data_ranges[n_th_vector]) <= 3,
+ AssertThrow (std::get<1>(vector_data_ranges[n_th_vector]) + 1
+ - std::get<0>(vector_data_ranges[n_th_vector]) <= 3,
ExcMessage ("Can't declare a vector with more than 3 components "
"in VTK"));
// mark these components as already
// written:
- for (unsigned int i=std_cxx11::get<0>(vector_data_ranges[n_th_vector]);
- i<=std_cxx11::get<1>(vector_data_ranges[n_th_vector]);
+ for (unsigned int i=std::get<0>(vector_data_ranges[n_th_vector]);
+ i<=std::get<1>(vector_data_ranges[n_th_vector]);
++i)
data_set_written[i] = true;
// name has been specified
out << " <DataArray type=\"Float64\" Name=\"";
- if (std_cxx11::get<2>(vector_data_ranges[n_th_vector]) != "")
- out << std_cxx11::get<2>(vector_data_ranges[n_th_vector]);
+ if (std::get<2>(vector_data_ranges[n_th_vector]) != "")
+ out << std::get<2>(vector_data_ranges[n_th_vector]);
else
{
- for (unsigned int i=std_cxx11::get<0>(vector_data_ranges[n_th_vector]);
- i<std_cxx11::get<1>(vector_data_ranges[n_th_vector]);
+ for (unsigned int i=std::get<0>(vector_data_ranges[n_th_vector]);
+ i<std::get<1>(vector_data_ranges[n_th_vector]);
++i)
out << data_names[i] << "__";
- out << data_names[std_cxx11::get<1>(vector_data_ranges[n_th_vector])];
+ out << data_names[std::get<1>(vector_data_ranges[n_th_vector])];
}
out << "\" NumberOfComponents=\"3\" format=\""
for (unsigned int n=0; n<n_nodes; ++n)
{
- switch (std_cxx11::get<1>(vector_data_ranges[n_th_vector]) -
- std_cxx11::get<0>(vector_data_ranges[n_th_vector]))
+ switch (std::get<1>(vector_data_ranges[n_th_vector]) -
+ std::get<0>(vector_data_ranges[n_th_vector]))
{
case 0:
- data.push_back (data_vectors(std_cxx11::get<0>(vector_data_ranges[n_th_vector]), n));
+ data.push_back (data_vectors(std::get<0>(vector_data_ranges[n_th_vector]), n));
data.push_back (0);
data.push_back (0);
break;
case 1:
- data.push_back (data_vectors(std_cxx11::get<0>(vector_data_ranges[n_th_vector]), n));
- data.push_back (data_vectors(std_cxx11::get<0>(vector_data_ranges[n_th_vector])+1, n));
+ data.push_back (data_vectors(std::get<0>(vector_data_ranges[n_th_vector]), n));
+ data.push_back (data_vectors(std::get<0>(vector_data_ranges[n_th_vector])+1, n));
data.push_back (0);
break;
case 2:
- data.push_back (data_vectors(std_cxx11::get<0>(vector_data_ranges[n_th_vector]), n));
- data.push_back (data_vectors(std_cxx11::get<0>(vector_data_ranges[n_th_vector])+1, n));
- data.push_back (data_vectors(std_cxx11::get<0>(vector_data_ranges[n_th_vector])+2, n));
+ data.push_back (data_vectors(std::get<0>(vector_data_ranges[n_th_vector]), n));
+ data.push_back (data_vectors(std::get<0>(vector_data_ranges[n_th_vector])+1, n));
+ data.push_back (data_vectors(std::get<0>(vector_data_ranges[n_th_vector])+2, n));
break;
default:
write_pvtu_record (std::ostream &out,
const std::vector<std::string> &piece_names,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges)
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges)
{
AssertThrow (out, ExcIO());
std::vector<bool> data_set_written (n_data_sets, false);
for (unsigned int n_th_vector=0; n_th_vector<vector_data_ranges.size(); ++n_th_vector)
{
- AssertThrow (std_cxx11::get<1>(vector_data_ranges[n_th_vector]) >=
- std_cxx11::get<0>(vector_data_ranges[n_th_vector]),
- ExcLowerRange (std_cxx11::get<1>(vector_data_ranges[n_th_vector]),
- std_cxx11::get<0>(vector_data_ranges[n_th_vector])));
- AssertThrow (std_cxx11::get<1>(vector_data_ranges[n_th_vector]) < n_data_sets,
- ExcIndexRange (std_cxx11::get<1>(vector_data_ranges[n_th_vector]),
+ AssertThrow (std::get<1>(vector_data_ranges[n_th_vector]) >=
+ std::get<0>(vector_data_ranges[n_th_vector]),
+ ExcLowerRange (std::get<1>(vector_data_ranges[n_th_vector]),
+ std::get<0>(vector_data_ranges[n_th_vector])));
+ AssertThrow (std::get<1>(vector_data_ranges[n_th_vector]) < n_data_sets,
+ ExcIndexRange (std::get<1>(vector_data_ranges[n_th_vector]),
0, n_data_sets));
- AssertThrow (std_cxx11::get<1>(vector_data_ranges[n_th_vector]) + 1
- - std_cxx11::get<0>(vector_data_ranges[n_th_vector]) <= 3,
+ AssertThrow (std::get<1>(vector_data_ranges[n_th_vector]) + 1
+ - std::get<0>(vector_data_ranges[n_th_vector]) <= 3,
ExcMessage ("Can't declare a vector with more than 3 components "
"in VTK"));
// mark these components as already
// written:
- for (unsigned int i=std_cxx11::get<0>(vector_data_ranges[n_th_vector]);
- i<=std_cxx11::get<1>(vector_data_ranges[n_th_vector]);
+ for (unsigned int i=std::get<0>(vector_data_ranges[n_th_vector]);
+ i<=std::get<1>(vector_data_ranges[n_th_vector]);
++i)
data_set_written[i] = true;
// name has been specified
out << " <PDataArray type=\"Float64\" Name=\"";
- if (std_cxx11::get<2>(vector_data_ranges[n_th_vector]) != "")
- out << std_cxx11::get<2>(vector_data_ranges[n_th_vector]);
+ if (std::get<2>(vector_data_ranges[n_th_vector]) != "")
+ out << std::get<2>(vector_data_ranges[n_th_vector]);
else
{
- for (unsigned int i=std_cxx11::get<0>(vector_data_ranges[n_th_vector]);
- i<std_cxx11::get<1>(vector_data_ranges[n_th_vector]);
+ for (unsigned int i=std::get<0>(vector_data_ranges[n_th_vector]);
+ i<std::get<1>(vector_data_ranges[n_th_vector]);
++i)
out << data_names[i] << "__";
- out << data_names[std_cxx11::get<1>(vector_data_ranges[n_th_vector])];
+ out << data_names[std::get<1>(vector_data_ranges[n_th_vector])];
}
out << "\" NumberOfComponents=\"3\" format=\"ascii\"/>\n";
template <int dim, int spacedim>
void write_svg (const std::vector<Patch<dim,spacedim> > &,
const std::vector<std::string> &,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &,
const SvgFlags &,
std::ostream &)
{
template <int spacedim>
void write_svg (const std::vector<Patch<2,spacedim> > &patches,
const std::vector<std::string> &/*data_names*/,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &/*vector_data_ranges*/,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &/*vector_data_ranges*/,
const SvgFlags &flags,
std::ostream &out)
{
void
write_deal_II_intermediate (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const Deal_II_IntermediateFlags &/*flags*/,
std::ostream &out)
{
out << vector_data_ranges.size() << '\n';
for (unsigned int i=0; i<vector_data_ranges.size(); ++i)
- out << std_cxx11::get<0>(vector_data_ranges[i]) << ' '
- << std_cxx11::get<1>(vector_data_ranges[i]) << '\n'
- << std_cxx11::get<2>(vector_data_ranges[i]) << '\n';
+ out << std::get<0>(vector_data_ranges[i]) << ' '
+ << std::get<1>(vector_data_ranges[i]) << '\n'
+ << std::get<2>(vector_data_ranges[i]) << '\n';
out << '\n';
// make sure everything now gets to
template <int dim, int spacedim>
void DataOutBase::write_filtered_data (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
DataOutBase::DataOutFilter &filtered_data)
{
const unsigned int n_data_sets = data_names.size();
for (n_th_vector=0,data_set=0; data_set<n_data_sets;)
{
// Advance n_th_vector to at least the current data set we are on
- while (n_th_vector < vector_data_ranges.size() && std_cxx11::get<0>(vector_data_ranges[n_th_vector]) < data_set) n_th_vector++;
+ while (n_th_vector < vector_data_ranges.size() && std::get<0>(vector_data_ranges[n_th_vector]) < data_set) n_th_vector++;
// Determine the dimension of this data
- if (n_th_vector < vector_data_ranges.size() && std_cxx11::get<0>(vector_data_ranges[n_th_vector]) == data_set)
+ if (n_th_vector < vector_data_ranges.size() && std::get<0>(vector_data_ranges[n_th_vector]) == data_set)
{
// Multiple dimensions
- pt_data_vector_dim = std_cxx11::get<1>(vector_data_ranges[n_th_vector]) - std_cxx11::get<0>(vector_data_ranges[n_th_vector])+1;
+ pt_data_vector_dim = std::get<1>(vector_data_ranges[n_th_vector]) - std::get<0>(vector_data_ranges[n_th_vector])+1;
// Ensure the dimensionality of the data is correct
- AssertThrow (std_cxx11::get<1>(vector_data_ranges[n_th_vector]) >= std_cxx11::get<0>(vector_data_ranges[n_th_vector]),
- ExcLowerRange (std_cxx11::get<1>(vector_data_ranges[n_th_vector]), std_cxx11::get<0>(vector_data_ranges[n_th_vector])));
- AssertThrow (std_cxx11::get<1>(vector_data_ranges[n_th_vector]) < n_data_sets,
- ExcIndexRange (std_cxx11::get<1>(vector_data_ranges[n_th_vector]), 0, n_data_sets));
+ AssertThrow (std::get<1>(vector_data_ranges[n_th_vector]) >= std::get<0>(vector_data_ranges[n_th_vector]),
+ ExcLowerRange (std::get<1>(vector_data_ranges[n_th_vector]), std::get<0>(vector_data_ranges[n_th_vector])));
+ AssertThrow (std::get<1>(vector_data_ranges[n_th_vector]) < n_data_sets,
+ ExcIndexRange (std::get<1>(vector_data_ranges[n_th_vector]), 0, n_data_sets));
// Determine the vector name
// Concatenate all the
// component names with double
// underscores unless a vector
// name has been specified
- if (std_cxx11::get<2>(vector_data_ranges[n_th_vector]) != "")
+ if (std::get<2>(vector_data_ranges[n_th_vector]) != "")
{
- vector_name = std_cxx11::get<2>(vector_data_ranges[n_th_vector]);
+ vector_name = std::get<2>(vector_data_ranges[n_th_vector]);
}
else
{
vector_name = "";
- for (i=std_cxx11::get<0>(vector_data_ranges[n_th_vector]); i<std_cxx11::get<1>(vector_data_ranges[n_th_vector]); ++i)
+ for (i=std::get<0>(vector_data_ranges[n_th_vector]); i<std::get<1>(vector_data_ranges[n_th_vector]); ++i)
vector_name += data_names[i] + "__";
- vector_name += data_names[std_cxx11::get<1>(vector_data_ranges[n_th_vector])];
+ vector_name += data_names[std::get<1>(vector_data_ranges[n_th_vector])];
}
}
else
template <int dim, int spacedim>
-std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> >
+std::vector<std::tuple<unsigned int, unsigned int, std::string> >
DataOutInterface<dim,spacedim>::get_vector_data_ranges () const
{
- return std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> >();
+ return std::vector<std::tuple<unsigned int, unsigned int, std::string> >();
}
// complicated, because vector ranges might have a name or not.
std::set<std::string> all_names;
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> >
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> >
ranges = this->get_vector_data_ranges();
const std::vector<std::string> data_names = this->get_dataset_names();
const unsigned int n_data_sets = data_names.size();
for (unsigned int n_th_vector=0; n_th_vector<ranges.size(); ++n_th_vector)
{
- const std::string &name = std_cxx11::get<2>(ranges[n_th_vector]);
+ const std::string &name = std::get<2>(ranges[n_th_vector]);
if (name != "")
{
Assert(all_names.find(name) == all_names.end(),
ExcMessage("Error: names of fields in DataOut need to be unique, "
"but '" + name + "' is used more than once."));
all_names.insert(name);
- for (unsigned int i=std_cxx11::get<0>(ranges[n_th_vector]);
- i<=std_cxx11::get<1>(ranges[n_th_vector]);
+ for (unsigned int i=std::get<0>(ranges[n_th_vector]);
+ i<=std::get<1>(ranges[n_th_vector]);
++i)
data_set_written[i] = true;
}
tmp.swap (dataset_names);
}
{
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > tmp;
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> > tmp;
tmp.swap (vector_data_ranges);
}
vector_data_ranges.resize (n_vector_data_ranges);
for (unsigned int i=0; i<n_vector_data_ranges; ++i)
{
- in >> std_cxx11::get<0>(vector_data_ranges[i])
- >> std_cxx11::get<1>(vector_data_ranges[i]);
+ in >> std::get<0>(vector_data_ranges[i])
+ >> std::get<1>(vector_data_ranges[i]);
// read in the name of that vector
// range. because it is on a separate
std::string name;
getline(in, name);
getline(in, name);
- std_cxx11::get<2>(vector_data_ranges[i]) = name;
+ std::get<2>(vector_data_ranges[i]) = name;
}
AssertThrow (in, ExcIO());
"as vectors."));
for (unsigned int i=0; i<get_vector_data_ranges().size(); ++i)
{
- Assert (std_cxx11::get<0>(get_vector_data_ranges()[i]) ==
- std_cxx11::get<0>(source.get_vector_data_ranges()[i]),
+ Assert (std::get<0>(get_vector_data_ranges()[i]) ==
+ std::get<0>(source.get_vector_data_ranges()[i]),
ExcMessage ("Both sources need to declare the same components "
"as vectors."));
- Assert (std_cxx11::get<1>(get_vector_data_ranges()[i]) ==
- std_cxx11::get<1>(source.get_vector_data_ranges()[i]),
+ Assert (std::get<1>(get_vector_data_ranges()[i]) ==
+ std::get<1>(source.get_vector_data_ranges()[i]),
ExcMessage ("Both sources need to declare the same components "
"as vectors."));
- Assert (std_cxx11::get<2>(get_vector_data_ranges()[i]) ==
- std_cxx11::get<2>(source.get_vector_data_ranges()[i]),
+ Assert (std::get<2>(get_vector_data_ranges()[i]) ==
+ std::get<2>(source.get_vector_data_ranges()[i]),
ExcMessage ("Both sources need to declare the same components "
"as vectors."));
}
template <int dim, int spacedim>
-std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> >
+std::vector<std::tuple<unsigned int, unsigned int, std::string> >
DataOutReader<dim,spacedim>::get_vector_data_ranges () const
{
return vector_data_ranges;
void
write_vtk (const std::vector<Patch<deal_II_dimension,deal_II_space_dimension> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const VtkFlags &flags,
std::ostream &out);
void
write_vtu (const std::vector<Patch<deal_II_dimension,deal_II_space_dimension> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const VtkFlags &flags,
std::ostream &out);
void
write_ucd (const std::vector<Patch<deal_II_dimension,deal_II_space_dimension> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const UcdFlags &flags,
std::ostream &out);
void
write_dx (const std::vector<Patch<deal_II_dimension,deal_II_space_dimension> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const DXFlags &flags,
std::ostream &out);
void
write_gnuplot (const std::vector<Patch<deal_II_dimension,deal_II_space_dimension> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const GnuplotFlags &flags,
std::ostream &out);
void
write_povray (const std::vector<Patch<deal_II_dimension,deal_II_space_dimension> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const PovrayFlags &flags,
std::ostream &out);
void
write_eps (const std::vector<Patch<deal_II_dimension,deal_II_space_dimension> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const EpsFlags &flags,
std::ostream &out);
void
write_gmv (const std::vector<Patch<deal_II_dimension,deal_II_space_dimension> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const GmvFlags &flags,
std::ostream &out);
void
write_tecplot (const std::vector<Patch<deal_II_dimension,deal_II_space_dimension> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const TecplotFlags &flags,
std::ostream &out);
void
write_tecplot_binary (const std::vector<Patch<deal_II_dimension,deal_II_space_dimension> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const TecplotFlags &flags,
std::ostream &out);
void
write_svg (const std::vector<Patch<deal_II_dimension,deal_II_space_dimension> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const SvgFlags &flags,
std::ostream &out);
#endif
void
write_deal_II_intermediate (const std::vector<Patch<deal_II_dimension,deal_II_space_dimension> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const Deal_II_IntermediateFlags &flags,
std::ostream &out);
\}
template <int dim>
InterpolatedTensorProductGridData<dim>::
- InterpolatedTensorProductGridData(const std_cxx11::array<std::vector<double>,dim> &coordinate_values,
+ InterpolatedTensorProductGridData(const std::array<std::vector<double>,dim> &coordinate_values,
const Table<dim,double> &data_values)
:
coordinate_values (coordinate_values),
template <int dim>
InterpolatedUniformGridData<dim>::
- InterpolatedUniformGridData(const std_cxx11::array<std::pair<double,double>,dim> &interval_endpoints,
- const std_cxx11::array<unsigned int,dim> &n_subintervals,
+ InterpolatedUniformGridData(const std::array<std::pair<double,double>,dim> &interval_endpoints,
+ const std::array<unsigned int,dim> &n_subintervals,
const Table<dim,double> &data_values)
:
interval_endpoints (interval_endpoints),
const unsigned int component) const
{
const Point<dim> p = p_ - coordinate_system_offset;
- const std_cxx11::array<double, dim> sp = GeometricUtilities::Coordinates::to_spherical(p);
+ const std::array<double, dim> sp = GeometricUtilities::Coordinates::to_spherical(p);
return svalue(sp, component);
}
const unsigned int component) const
{
const Point<dim> p = p_ - coordinate_system_offset;
- const std_cxx11::array<double, dim> sp = GeometricUtilities::Coordinates::to_spherical(p);
- const std_cxx11::array<double, dim> sg = sgradient(sp, component);
+ const std::array<double, dim> sp = GeometricUtilities::Coordinates::to_spherical(p);
+ const std::array<double, dim> sg = sgradient(sp, component);
// somewhat backwards, but we need cos/sin's for unit vectors
const double cos_theta = std::cos(sp[1]);
const unsigned int component) const
{
const Point<dim> p = p_ - coordinate_system_offset;
- const std_cxx11::array<double, dim> sp = GeometricUtilities::Coordinates::to_spherical(p);
- const std_cxx11::array<double, dim> sg = sgradient(sp, component);
- const std_cxx11::array<double, 6> sh = shessian(sp, component);
+ const std::array<double, dim> sp = GeometricUtilities::Coordinates::to_spherical(p);
+ const std::array<double, dim> sg = sgradient(sp, component);
+ const std::array<double, 6> sh = shessian(sp, component);
// somewhat backwards, but we need cos/sin's for unit vectors
const double cos_theta = std::cos(sp[1]);
template <int dim>
double
- Spherical<dim>::svalue(const std_cxx11::array<double, dim> & /* sp */,
+ Spherical<dim>::svalue(const std::array<double, dim> & /* sp */,
const unsigned int /*component*/) const
{
AssertThrow(false,
template <int dim>
- std_cxx11::array<double, dim>
- Spherical<dim>::sgradient(const std_cxx11::array<double, dim> & /* sp */,
+ std::array<double, dim>
+ Spherical<dim>::sgradient(const std::array<double, dim> & /* sp */,
const unsigned int /*component*/) const
{
AssertThrow(false,
ExcNotImplemented());
- return std_cxx11::array<double,dim>();
+ return std::array<double,dim>();
}
template <int dim>
- std_cxx11::array<double, 6>
- Spherical<dim>::shessian (const std_cxx11::array<double, dim> & /* sp */,
+ std::array<double, 6>
+ Spherical<dim>::shessian (const std::array<double, dim> & /* sp */,
const unsigned int /*component*/) const
{
AssertThrow(false,
ExcNotImplemented());
- return std_cxx11::array<double, 6>();
+ return std::array<double, 6>();
}
template <int dim>
- std_cxx11::array<double,dim>
+ std::array<double,dim>
to_spherical(const Point<dim> &position)
{
- std_cxx11::array<double,dim> scoord;
+ std::array<double,dim> scoord;
// radius
scoord[0] = position.norm();
template <std::size_t dim>
Point<dim>
- from_spherical(const std_cxx11::array<double,dim> &scoord)
+ from_spherical(const std::array<double,dim> &scoord)
{
Point<dim> ccoord;
}
- template Point<2> from_spherical<2>(const std_cxx11::array<double,2> &);
- template Point<3> from_spherical<3>(const std_cxx11::array<double,3> &);
- template std_cxx11::array<double,2> to_spherical<2>(const Point<2> &);
- template std_cxx11::array<double,3> to_spherical<3>(const Point<3> &);
+ template Point<2> from_spherical<2>(const std::array<double,2> &);
+ template Point<3> from_spherical<3>(const std::array<double,3> &);
+ template std::array<double,2> to_spherical<2>(const Point<2> &);
+ template std::array<double,3> to_spherical<3>(const Point<3> &);
}
}
std::string str;
std::getline(is, str, '>');
- std
_cxx11::shared_ptr<PatternBase> base_pattern (pattern_factory(str));
+ std::shared_ptr<PatternBase> base_pattern (pattern_factory(str));
is.ignore(strlen(" of length "));
if (!(is >> min_elements))
std::string value = str;
value.erase (0, value.find(":")+1);
- std
_cxx11::shared_ptr<PatternBase> key_pattern (pattern_factory(key));
- std
_cxx11::shared_ptr<PatternBase> value_pattern (pattern_factory(value));
+ std::shared_ptr<PatternBase> key_pattern (pattern_factory(key));
+ std::shared_ptr<PatternBase> value_pattern (pattern_factory(value));
is.ignore(strlen(" of length "));
if (!(is >> min_elements))
read_xml_recursively (const boost::property_tree::ptree &source,
const std::string ¤t_path,
const char path_separator,
- const std::vector<std_cxx11::shared_ptr<const Patterns::PatternBase> > &
+ const std::vector<std::shared_ptr<const Patterns::PatternBase> > &
patterns,
boost::property_tree::ptree &destination)
{
// clone the pattern and store its
// index in the node
- patterns.push_back (std_cxx11::shared_ptr<const Patterns::PatternBase>
+ patterns.push_back (std::shared_ptr<const Patterns::PatternBase>
(pattern.clone()));
entries->put (get_current_full_path(entry) + path_separator + "pattern",
static_cast<unsigned int>(patterns.size()-1));
// need to transform p into standard form as
// well if necessary. copy the polynomial to
// do this
- std
_cxx11::shared_ptr<Polynomial<number> > q_data;
+ std::shared_ptr<Polynomial<number> > q_data;
const Polynomial<number> *q = 0;
if (p.in_lagrange_product_form == true)
{
// need to transform p into standard form as
// well if necessary. copy the polynomial to
// do this
- std
_cxx11::shared_ptr<Polynomial<number> > q_data;
+ std::shared_ptr<Polynomial<number> > q_data;
const Polynomial<number> *q = 0;
if (p.in_lagrange_product_form == true)
{
// need to transform p into standard form as
// well if necessary. copy the polynomial to
// do this
- std
_cxx11::shared_ptr<Polynomial<number> > q_data;
+ std::shared_ptr<Polynomial<number> > q_data;
const Polynomial<number> *q = 0;
if (p.in_lagrange_product_form == true)
{
if (degree() == 0)
return Monomial<number>(0, 0.);
- std
_cxx11::shared_ptr<Polynomial<number> > q_data;
+ std::shared_ptr<Polynomial<number> > q_data;
const Polynomial<number> *q = 0;
if (in_lagrange_product_form == true)
{
{
// no simple form possible for Lagrange
// polynomial on product form
- std
_cxx11::shared_ptr<Polynomial<number> > q_data;
+ std::shared_ptr<Polynomial<number> > q_data;
const Polynomial<number> *q = 0;
if (in_lagrange_product_form == true)
{
// Reserve space for polynomials up to degree 19. Should be sufficient
// for the start.
- std::vector<std_cxx11::shared_ptr<const std::vector<double> > >
+ std::vector<std::shared_ptr<const std::vector<double> > >
Hierarchical::recursive_coefficients(20);
// now make these arrays
// const
recursive_coefficients[0] =
- std_cxx11::shared_ptr<const std::vector<double> >(c0);
+ std::shared_ptr<const std::vector<double> >(c0);
recursive_coefficients[1] =
- std_cxx11::shared_ptr<const std::vector<double> >(c1);
+ std::shared_ptr<const std::vector<double> >(c1);
}
else if (k==2)
{
(*c2)[2] = 4.*a;
recursive_coefficients[2] =
- std_cxx11::shared_ptr<const std::vector<double> >(c2);
+ std::shared_ptr<const std::vector<double> >(c2);
}
else
{
// const pointer in the
// coefficients array
recursive_coefficients[k] =
- std_cxx11::shared_ptr<const std::vector<double> >(ck);
+ std::shared_ptr<const std::vector<double> >(ck);
};
};
}
#include <deal.II/base/quadrature_lib.h>
#include <deal.II/base/geometry_info.h>
-#include <deal.II/base/std_cxx11/bind.h>
-
#include <cmath>
#include <limits>
#include <algorithm>
+#include <functional>
DEAL_II_NAMESPACE_OPEN
std::sort(permutation.begin(),
permutation.end(),
- std_cxx11::bind(&QSorted<dim>::compare_weights,
- std_cxx11::ref(*this),
- std_cxx11::_1,
- std_cxx11::_2));
+ std::bind(&QSorted<dim>::compare_weights,
+ std::ref(*this),
+ std::placeholders::_1,
+ std::placeholders::_2));
for (unsigned int i=0; i<quad.size(); ++i)
{
#include <deal.II/base/polynomials_piecewise.h>
#include <deal.II/base/exceptions.h>
#include <deal.II/base/table.h>
-#include <deal.II/base/std_cxx11/array.h>
+
+#include <array>
DEAL_II_NAMESPACE_OPEN
// derivatives, up to the 4th derivative, for up to 20 polynomials).
// If someone uses a larger number of
// polynomials, we need to allocate more memory on the heap.
- std_cxx11::array<std_cxx11::array<double,5>, dim> *v;
- std_cxx11::array<std_cxx11::array<std_cxx11::array<double,5>, dim>, 20> small_array;
- std::vector<std_cxx11::array<std_cxx11::array<double,5>, dim> > large_array;
+ std::array<std::array<double,5>, dim> *v;
+ std::array<std::array<std::array<double,5>, dim>, 20> small_array;
+ std::vector<std::array<std::array<double,5>, dim> > large_array;
const unsigned int n_polynomials = polynomials.size();
if (n_polynomials > 20)
#include <deal.II/base/utilities.h>
-#include <deal.II/base/std_cxx11/bind.h>
#include <deal.II/lac/vector.h>
#include <deal.II/lac/block_vector.h>
#include <deal.II/lac/petsc_vector.h>
#include <numeric>
#include <algorithm>
#include <limits>
+#include <functional>
DEAL_II_NAMESPACE_OPEN
unsigned int
my_count = std::count_if (criteria.begin(),
criteria.end(),
- std_cxx11::bind (std::greater<double>(),
- std_cxx11::_1,
- test_threshold));
+ std::bind (std::greater<double>(),
+ std::placeholders::_1,
+ test_threshold));
unsigned int total_count;
ierr = MPI_Reduce (&my_count, &total_count, 1, MPI_UNSIGNED,
{
// get halo layer of (ghost) cells
// parallel::shared::Triangulation<dim>::
- std_cxx11::function<bool (const typename parallel::shared::Triangulation<dim,spacedim>::active_cell_iterator &)> predicate
+ std::function<bool (const typename parallel::shared::Triangulation<dim,spacedim>::active_cell_iterator &)> predicate
= IteratorFilters::SubdomainEqualTo(this->my_subdomain);
const std::vector<typename parallel::shared::Triangulation<dim,spacedim>::active_cell_iterator>
#include <deal.II/grid/tria_accessor.h>
#include <deal.II/grid/tria_iterator.h>
-#include <deal.II/base/std_cxx11/bind.h>
+#include <functional>
DEAL_II_NAMESPACE_OPEN
offset
= tria->register_data_attach(size,
- std_cxx11::bind(&SolutionTransfer<dim, VectorType,
- DoFHandlerType>::pack_callback,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3));
+ std::bind(&SolutionTransfer<dim, VectorType,
+ DoFHandlerType>::pack_callback,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3));
}
Assert (tria != 0, ExcInternalError());
tria->notify_ready_to_unpack(offset,
- std_cxx11::bind(&SolutionTransfer<dim, VectorType,
- DoFHandlerType>::unpack_callback,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3,
- std_cxx11::ref(all_out)));
+ std::bind(&SolutionTransfer<dim, VectorType,
+ DoFHandlerType>::unpack_callback,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3,
+ std::ref(all_out)));
for (typename std::vector<VectorType *>::iterator it=all_out.begin();
attach_mesh_data_recursively (const typename internal::p4est::types<dim>::tree &tree,
const typename Triangulation<dim,spacedim>::cell_iterator &dealii_cell,
const typename internal::p4est::types<dim>::quadrant &p4est_cell,
- const typename std::list<std::pair<unsigned int, typename std_cxx11::function<
+ const typename std::list<std::pair<unsigned int, typename std::function<
void(typename parallel::distributed::Triangulation<dim,spacedim>::cell_iterator,
typename parallel::distributed::Triangulation<dim,spacedim>::CellStatus,
void *)
> > > &attached_data_pack_callbacks)
{
- typedef std::list<std::pair<unsigned int, typename std_cxx11::function<
+ typedef std::list<std::pair<unsigned int, typename std::function<
void(typename parallel::distributed::Triangulation<dim,spacedim>::cell_iterator,
typename parallel::distributed::Triangulation<dim,spacedim>::CellStatus,
void *)
const typename Triangulation<dim,spacedim>::cell_iterator &parent_cell,
const typename internal::p4est::types<dim>::quadrant &p4est_cell,
const unsigned int offset,
- const typename std_cxx11::function<
+ const typename std::function<
void(typename parallel::distributed::Triangulation<dim,spacedim>::cell_iterator, typename parallel::distributed::Triangulation<dim,spacedim>::CellStatus, void *)
> &unpack_callback)
{
unsigned int
Triangulation<dim,spacedim>::
register_data_attach (const std::size_t size,
- const std_cxx11::function<void(const cell_iterator &,
- const CellStatus,
- void *)> &pack_callback)
+ const std::function<void(const cell_iterator &,
+ const CellStatus,
+ void *)> &pack_callback)
{
Assert(size>0, ExcMessage("register_data_attach(), size==0"));
Assert(attached_data_pack_callbacks.size()==n_attached_datas,
void
Triangulation<dim,spacedim>::
notify_ready_to_unpack (const unsigned int offset,
- const std_cxx11::function<void (const cell_iterator &,
- const CellStatus,
- const void *)> &unpack_callback)
+ const std::function<void (const cell_iterator &,
+ const CellStatus,
+ const void *)> &unpack_callback)
{
Assert (offset >= sizeof(CellStatus),
ExcMessage ("invalid offset in notify_ready_to_unpack()"));
subdomain_id < n_subdomains; ++subdomain_id)
{
// Extract the layer of cells around this subdomain
- std_cxx11::function<bool (const typename DoFHandlerType::active_cell_iterator &)> predicate
+ std::function<bool (const typename DoFHandlerType::active_cell_iterator &)> predicate
= IteratorFilters::SubdomainEqualTo(subdomain_id);
const std::vector<typename DoFHandlerType::active_cell_iterator>
active_halo_layer = GridTools::compute_active_cell_halo_layer (dof_handler,
//
// ---------------------------------------------------------------------
-#include <deal.II/base/std_cxx1x/array.h>
#include <deal.II/base/thread_management.h>
#include <deal.II/base/table.h>
#include <deal.II/base/template_constraints.h>
#endif
#include <algorithm>
+#include <array>
#include <numeric>
DEAL_II_NAMESPACE_OPEN
ensure_existence_of_master_dof_mask (const FiniteElement<dim,spacedim> &fe1,
const FiniteElement<dim,spacedim> &fe2,
const FullMatrix<double> &face_interpolation_matrix,
- std_cxx11::shared_ptr<std::vector<bool> > &master_dof_mask)
+ std::shared_ptr<std::vector<bool> > &master_dof_mask)
{
- if (master_dof_mask == std_cxx11::shared_ptr<std::vector<bool> >())
+ if (master_dof_mask == std::shared_ptr<std::vector<bool> >())
{
- master_dof_mask = std_cxx11::shared_ptr<std::vector<bool> >
+ master_dof_mask = std::shared_ptr<std::vector<bool> >
(new std::vector<bool> (fe1.dofs_per_face));
select_master_dofs_for_face_restriction (fe1,
fe2,
void
ensure_existence_of_face_matrix (const FiniteElement<dim,spacedim> &fe1,
const FiniteElement<dim,spacedim> &fe2,
- std_cxx11::shared_ptr<FullMatrix<double> > &matrix)
+ std::shared_ptr<FullMatrix<double> > &matrix)
{
- if (matrix == std_cxx11::shared_ptr<FullMatrix<double> >())
+ if (matrix == std::shared_ptr<FullMatrix<double> >())
{
- matrix = std_cxx11::shared_ptr<FullMatrix<double> >
+ matrix = std::shared_ptr<FullMatrix<double> >
(new FullMatrix<double> (fe2.dofs_per_face,
fe1.dofs_per_face));
fe1.get_face_interpolation_matrix (fe2,
ensure_existence_of_subface_matrix (const FiniteElement<dim,spacedim> &fe1,
const FiniteElement<dim,spacedim> &fe2,
const unsigned int subface,
- std_cxx11::shared_ptr<FullMatrix<double> > &matrix)
+ std::shared_ptr<FullMatrix<double> > &matrix)
{
- if (matrix == std_cxx11::shared_ptr<FullMatrix<double> >())
+ if (matrix == std::shared_ptr<FullMatrix<double> >())
{
- matrix = std_cxx11::shared_ptr<FullMatrix<double> >
+ matrix = std::shared_ptr<FullMatrix<double> >
(new FullMatrix<double> (fe2.dofs_per_face,
fe1.dofs_per_face));
fe1.get_subface_interpolation_matrix (fe2,
void
ensure_existence_of_split_face_matrix (const FullMatrix<double> &face_interpolation_matrix,
const std::vector<bool> &master_dof_mask,
- std_cxx11::shared_ptr<std::pair<FullMatrix<double>,FullMatrix<double> > > &split_matrix)
+ std::shared_ptr<std::pair<FullMatrix<double>,FullMatrix<double> > > &split_matrix)
{
AssertDimension (master_dof_mask.size(), face_interpolation_matrix.m());
Assert (std::count (master_dof_mask.begin(), master_dof_mask.end(), true) ==
ExcInternalError());
if (split_matrix ==
- std_cxx11::shared_ptr<std::pair<FullMatrix<double>,FullMatrix<double> > >())
+ std::shared_ptr<std::pair<FullMatrix<double>,FullMatrix<double> > >())
{
split_matrix
- = std_cxx11::shared_ptr<std::pair<FullMatrix<double>,FullMatrix<double> > >
+ = std::shared_ptr<std::pair<FullMatrix<double>,FullMatrix<double> > >
(new std::pair<FullMatrix<double>,FullMatrix<double> >());
const unsigned int n_master_dofs = face_interpolation_matrix.n();
// different (or the same) finite elements. we compute them only
// once, namely the first time they are needed, and then just reuse
// them
- Table<2,std_cxx11::shared_ptr<FullMatrix<double> > >
+ Table<2,std::shared_ptr<FullMatrix<double> > >
face_interpolation_matrices (n_finite_elements (dof_handler),
n_finite_elements (dof_handler));
- Table<3,std_cxx11::shared_ptr<FullMatrix<double> > >
+ Table<3,std::shared_ptr<FullMatrix<double> > >
subface_interpolation_matrices (n_finite_elements (dof_handler),
n_finite_elements (dof_handler),
GeometryInfo<dim>::max_children_per_face);
// master and slave parts, and for which the master part is inverted.
// these two matrices are derived from the face interpolation matrix
// as described in the @ref hp_paper "hp paper"
- Table<2,std_cxx11::shared_ptr<std::pair<FullMatrix<double>,FullMatrix<double> > > >
+ Table<2,std::shared_ptr<std::pair<FullMatrix<double>,FullMatrix<double> > > >
split_face_interpolation_matrices (n_finite_elements (dof_handler),
n_finite_elements (dof_handler));
// finally, for each pair of finite elements, have a mask that states
// which of the degrees of freedom on the coarse side of a refined
// face will act as master dofs.
- Table<2,std_cxx11::shared_ptr<std::vector<bool> > >
+ Table<2,std::shared_ptr<std::vector<bool> > >
master_dof_masks (n_finite_elements (dof_handler),
n_finite_elements (dof_handler));
// have an array that stores the location of each vector-dof tuple
// we want to rotate.
- typedef std_cxx1x::array<unsigned int, spacedim> DoFTuple;
+ typedef std::array<unsigned int, spacedim> DoFTuple;
// start with a pristine interpolation matrix...
FullMatrix<double> transformation = IdentityMatrix(n_dofs_per_face);
WorkStream::run(coarse_grid.begin_active(),
coarse_grid.end(),
- std_cxx11::bind(&compute_intergrid_weights_3<dim,spacedim>,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3,
- coarse_component,
- std_cxx11::cref(coarse_grid.get_fe()),
- std_cxx11::cref(coarse_to_fine_grid_map),
- std_cxx11::cref(parameter_dofs)),
- std_cxx11::bind(©_intergrid_weights_3<dim,spacedim>,
- std_cxx11::_1,
- coarse_component,
- std_cxx11::cref(coarse_grid.get_fe()),
- std_cxx11::cref(weight_mapping),
- is_called_in_parallel,
- std_cxx11::ref(weights)),
+ std::bind(&compute_intergrid_weights_3<dim,spacedim>,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3,
+ coarse_component,
+ std::cref(coarse_grid.get_fe()),
+ std::cref(coarse_to_fine_grid_map),
+ std::cref(parameter_dofs)),
+ std::bind(©_intergrid_weights_3<dim,spacedim>,
+ std::placeholders::_1,
+ coarse_component,
+ std::cref(coarse_grid.get_fe()),
+ std::cref(weight_mapping),
+ is_called_in_parallel,
+ std::ref(weights)),
scratch,
copy_data);
// now compute the requested representation
const types::global_dof_index n_global_parm_dofs
= std::count_if (weight_mapping.begin(), weight_mapping.end(),
- std_cxx11::bind (std::not_equal_to<types::global_dof_index>(), std_cxx11::_1, numbers::invalid_dof_index));
+ std::bind (std::not_equal_to<types::global_dof_index>(), std::placeholders::_1, numbers::invalid_dof_index));
// first construct the inverse mapping of weight_mapping
std::vector<types::global_dof_index> inverse_weight_mapping (n_global_parm_dofs,
n_nonzero_components_table (compute_n_nonzero_components(nonzero_components)),
cached_primitivity (std::find_if (n_nonzero_components_table.begin(),
n_nonzero_components_table.end(),
- std_cxx11::bind (std::not_equal_to<unsigned int>(),
- std_cxx11::_1,
- 1U))
+ std::bind (std::not_equal_to<unsigned int>(),
+ std::placeholders::_1,
+ 1U))
== n_nonzero_components_table.end())
{
Assert (restriction_is_additive_flags.size() == this->dofs_per_cell,
-std_cxx11::array<std_cxx11::array<double,3>,4>
+std::array<std::array<double,3>,4>
FE_P1NC::get_linear_shape_coefficients (const Triangulation<2,2>::cell_iterator &cell)
{
// edge midpoints
const double det = (mpt[0](0)-mpt[1](0))*(mpt[2](1)-mpt[3](1)) - (mpt[2](0)-mpt[3](0))*(mpt[0](1)-mpt[1](1));
- std_cxx11::array<std_cxx11::array<double,3>,4> coeffs;
+ std::array<std::array<double,3>,4> coeffs;
coeffs[0][0] = ((mpt[2](1)-mpt[3](1))*(0.5) -(mpt[0](1)-mpt[1](1))*(0.5))/det;
coeffs[1][0] = ((mpt[2](1)-mpt[3](1))*(-0.5) -(mpt[0](1)-mpt[1](1))*(0.5))/det;
coeffs[2][0] = ((mpt[2](1)-mpt[3](1))*(0.5) -(mpt[0](1)-mpt[1](1))*(-0.5))/det;
const unsigned int n_q_points = mapping_data.quadrature_points.size();
// linear shape functions
- std_cxx11::array<std_cxx11::array<double,3>,4> coeffs = get_linear_shape_coefficients (cell);
+ std::array<std::array<double,3>,4> coeffs = get_linear_shape_coefficients (cell);
// compute on the cell
if (flags & update_values)
const UpdateFlags flags(fe_internal.update_each);
// linear shape functions
- const std_cxx11::array<std_cxx11::array<double,3>,4> coeffs
+ const std::array<std::array<double,3>,4> coeffs
= get_linear_shape_coefficients (cell);
// compute on the face
const UpdateFlags flags(fe_internal.update_each);
// linear shape functions
- const std_cxx11::array<std_cxx11::array<double,3>,4> coeffs
+ const std::array<std::array<double,3>,4> coeffs
= get_linear_shape_coefficients (cell);
// compute on the subface
#include <deal.II/base/quadrature.h>
#include <deal.II/base/qprojector.h>
#include <deal.II/base/template_constraints.h>
-#include <deal.II/base/std_cxx11/unique_ptr.h>
#include <deal.II/fe/fe_q_bubbles.h>
#include <deal.II/fe/fe_nothing.h>
#include <deal.II/fe/fe_tools.h>
#include <vector>
#include <sstream>
+#include <memory>
DEAL_II_NAMESPACE_OPEN
const unsigned int degree = fe.degree;
// Initialize quadrature formula on fine cells
- std_cxx11::unique_ptr<Quadrature<dim> > q_fine;
+ std::unique_ptr<Quadrature<dim> > q_fine;
Quadrature<1> q_dummy(std::vector<Point<1> >(1), std::vector<double> (1,1.));
switch (dim)
{
if (multiplicities[i]>0)
{
base_elements[ind] =
- std::make_pair (std_cxx11::shared_ptr<const FiniteElement<dim,spacedim> >
+ std::make_pair (std::shared_ptr<const FiniteElement<dim,spacedim> >
(clone_base_elements[ind].return_value()),
multiplicities[i]);
++ind;
#include <deal.II/dofs/dof_tools.h>
#include <deal.II/hp/dof_handler.h>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
#include <deal.II/base/index_set.h>
#include <cctype>
#include <iostream>
+#include <memory>
DEAL_II_NAMESPACE_OPEN
template <int dim>
void
- fill_no_codim_fe_names (std::map<std::string,std_cxx11::shared_ptr<const Subscriptor> > &result)
+ fill_no_codim_fe_names (std::map<std::string,std::shared_ptr<const Subscriptor> > &result)
{
- typedef std_cxx11::shared_ptr<const Subscriptor> FEFactoryPointer;
+ typedef std::shared_ptr<const Subscriptor> FEFactoryPointer;
result["FE_Q_Hierarchical"]
= FEFactoryPointer(new FETools::FEFactory<FE_Q_Hierarchical<dim> >);
// nonzero codimension.
template <int dim, int spacedim>
void
- fill_codim_fe_names (std::map<std::string,std_cxx11::shared_ptr<const Subscriptor> > &result)
+ fill_codim_fe_names (std::map<std::string,std::shared_ptr<const Subscriptor> > &result)
{
- typedef std_cxx11::shared_ptr<const Subscriptor> FEFactoryPointer;
+ typedef std::shared_ptr<const Subscriptor> FEFactoryPointer;
result["FE_Bernstein"]
= FEFactoryPointer(new FETools::FEFactory<FE_Bernstein<dim,spacedim> >);
// by the functions above.
std::vector<std::vector<
std::map<std::string,
- std_cxx11::shared_ptr<const Subscriptor> > > >
+ std::shared_ptr<const Subscriptor> > > >
fill_default_map()
{
std::vector<std::vector<
std::map<std::string,
- std_cxx11::shared_ptr<const Subscriptor> > > >
+ std::shared_ptr<const Subscriptor> > > >
result(4);
for (unsigned int d=0; d<4; ++d)
static
std::vector<std::vector<
std::map<std::string,
- std_cxx11::shared_ptr<const Subscriptor> > > >
+ std::shared_ptr<const Subscriptor> > > >
fe_name_map = fill_default_map();
}
// Insert the normalized name into
// the map
fe_name_map[dim][spacedim][name] =
- std_cxx11::shared_ptr<const Subscriptor> (factory);
+ std::shared_ptr<const Subscriptor> (factory);
}
FiniteElement<dim,spacedim> *
get_fe_by_name_ext (std::string &name,
const std::map<std::string,
- std_cxx11::shared_ptr<const Subscriptor> >
+ std::shared_ptr<const Subscriptor> >
&fe_name_map)
{
// Extract the name of the
#include <deal.II/dofs/dof_tools.h>
#include <deal.II/hp/dof_handler.h>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
#include <deal.II/base/index_set.h>
#include <iostream>
+#include <memory>
DEAL_II_NAMESPACE_OPEN
// that memory is released again
std::map<const FiniteElement<dim,spacedim> *,
std::map<const FiniteElement<dim,spacedim> *,
- std_cxx11::shared_ptr<FullMatrix<double> > > >
+ std::shared_ptr<FullMatrix<double> > > >
interpolation_matrices;
typename DoFHandlerType1<dim,spacedim>::active_cell_iterator cell1 = dof1.begin_active(),
// there
if (interpolation_matrices[&cell1->get_fe()][&cell2->get_fe()].get() == 0)
{
- std_cxx11::shared_ptr<FullMatrix<double> >
+ std::shared_ptr<FullMatrix<double> >
interpolation_matrix (new FullMatrix<double> (dofs_per_cell2,
dofs_per_cell1));
interpolation_matrices[&cell1->get_fe()][&cell2->get_fe()]
// dof1 to the back_interpolation
// matrices
std::map<const FiniteElement<dim> *,
- std_cxx11::shared_ptr<FullMatrix<double> > > interpolation_matrices;
+ std::shared_ptr<FullMatrix<double> > > interpolation_matrices;
for (; cell!=endc; ++cell)
if ((cell->subdomain_id() == subdomain_id)
if (interpolation_matrices[&cell->get_fe()] == 0)
{
interpolation_matrices[&cell->get_fe()] =
- std_cxx11::shared_ptr<FullMatrix<double> >
+ std::shared_ptr<FullMatrix<double> >
(new FullMatrix<double>(dofs_per_cell1, dofs_per_cell1));
get_back_interpolation_matrix(cell->get_fe(), fe2,
*interpolation_matrices[&cell->get_fe()]);
#include <deal.II/base/multithread_info.h>
#include <deal.II/base/quadrature.h>
#include <deal.II/base/signaling_nan.h>
-#include <deal.II/base/std_cxx11/unique_ptr.h>
#include <deal.II/lac/vector.h>
#include <deal.II/lac/block_vector.h>
#include <deal.II/lac/la_vector.h>
#include <deal.II/fe/fe.h>
#include <iomanip>
+#include <memory>
DEAL_II_NAMESPACE_OPEN
invalidate_present_cell();
tria_listener_refinement =
cell->get_triangulation().signals.any_change.connect
- (std_cxx11::bind (&FEValuesBase<dim,spacedim>::invalidate_present_cell,
- std_cxx11::ref(static_cast<FEValuesBase<dim,spacedim>&>(*this))));
+ (std::bind (&FEValuesBase<dim,spacedim>::invalidate_present_cell,
+ std::ref(static_cast<FEValuesBase<dim,spacedim>&>(*this))));
tria_listener_mesh_transform =
cell->get_triangulation().signals.mesh_movement.connect
- (std_cxx11::bind (&FEValuesBase<dim,spacedim>::invalidate_present_cell,
- std_cxx11::ref(static_cast<FEValuesBase<dim,spacedim>&>(*this))));
+ (std::bind (&FEValuesBase<dim,spacedim>::invalidate_present_cell,
+ std::ref(static_cast<FEValuesBase<dim,spacedim>&>(*this))));
}
}
else
// changes
tria_listener_refinement =
cell->get_triangulation().signals.post_refinement.connect
- (std_cxx11::bind (&FEValuesBase<dim,spacedim>::invalidate_present_cell,
- std_cxx11::ref(static_cast<FEValuesBase<dim,spacedim>&>(*this))));
+ (std::bind (&FEValuesBase<dim,spacedim>::invalidate_present_cell,
+ std::ref(static_cast<FEValuesBase<dim,spacedim>&>(*this))));
tria_listener_mesh_transform =
cell->get_triangulation().signals.mesh_movement.connect
- (std_cxx11::bind (&FEValuesBase<dim,spacedim>::invalidate_present_cell,
- std_cxx11::ref(static_cast<FEValuesBase<dim,spacedim>&>(*this))));
+ (std::bind (&FEValuesBase<dim,spacedim>::invalidate_present_cell,
+ std::ref(static_cast<FEValuesBase<dim,spacedim>&>(*this))));
}
}
template <typename Type, typename Pointer, typename Iterator>
void
reset_pointer_in_place_if_possible
- (std
_cxx11::unique_ptr<Pointer> &present_cell,
+ (std::unique_ptr<Pointer> &present_cell,
const Iterator &new_cell)
{
// see if the existing pointer is non-null and if the type of
template <int dim, int spacedim>
-std
_cxx11::array<Point<spacedim>, GeometryInfo<dim>::vertices_per_cell>
+std::array<Point<spacedim>, GeometryInfo<dim>::vertices_per_cell>
Mapping<dim, spacedim>::get_vertices (
const typename Triangulation<dim,spacedim>::cell_iterator &cell) const
{
- std
_cxx11::array<Point<spacedim>, GeometryInfo<dim>::vertices_per_cell> vertices;
+ std::array<Point<spacedim>, GeometryInfo<dim>::vertices_per_cell> vertices;
for (unsigned int i = 0; i < GeometryInfo<dim>::vertices_per_cell; ++i)
{
vertices[i] = cell->vertex(i);
#include <deal.II/base/qprojector.h>
#include <deal.II/base/memory_consumption.h>
#include <deal.II/base/tensor_product_polynomials.h>
-#include <deal.II/base/std_cxx11/unique_ptr.h>
#include <deal.II/lac/full_matrix.h>
#include <deal.II/lac/vector.h>
#include <deal.II/lac/block_vector.h>
#include <numeric>
#include <fstream>
+#include <memory>
// the right size and transformation shape values already computed at point
// p.
const Quadrature<dim> point_quadrature(p);
- std_cxx11::unique_ptr<InternalData> mdata (get_data(update_quadrature_points | update_jacobians,
- point_quadrature));
+ std::unique_ptr<InternalData> mdata (get_data(update_quadrature_points | update_jacobians,
+ point_quadrature));
update_internal_dofs(cell, *mdata);
UpdateFlags update_flags = update_quadrature_points | update_jacobians;
if (spacedim>dim)
update_flags |= update_jacobian_grads;
- std_cxx11::unique_ptr<InternalData>
+ std::unique_ptr<InternalData>
mdata (get_data(update_flags,point_quadrature));
update_internal_dofs(cell, *mdata);
#include <deal.II/base/quadrature_lib.h>
#include <deal.II/base/tensor_product_polynomials.h>
#include <deal.II/base/memory_consumption.h>
-#include <deal.II/base/std_cxx11/array.h>
-#include <deal.II/base/std_cxx11/unique_ptr.h>
#include <deal.II/lac/full_matrix.h>
#include <deal.II/grid/tria.h>
#include <deal.II/grid/tria_iterator.h>
#include <cmath>
#include <algorithm>
#include <numeric>
+#include <array>
+#include <memory>
DEAL_II_NAMESPACE_OPEN
#include <deal.II/base/quadrature_lib.h>
#include <deal.II/base/memory_consumption.h>
#include <deal.II/base/tensor_product_polynomials.h>
-#include <deal.II/base/std_cxx11/unique_ptr.h>
#include <deal.II/lac/full_matrix.h>
#include <deal.II/grid/tria_iterator.h>
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/fe/fe_values.h>
#include <numeric>
+#include <memory>
DEAL_II_NAMESPACE_OPEN
// created via the shared_ptr objects
qp_mapping (this->polynomial_degree>1
?
- std_cxx11::shared_ptr<const MappingQGeneric<dim,spacedim> >(new MappingQGeneric<dim,spacedim>(degree))
+ std::shared_ptr<const MappingQGeneric<dim,spacedim> >(new MappingQGeneric<dim,spacedim>(degree))
:
q1_mapping)
{}
// created via the shared_ptr objects
qp_mapping (this->polynomial_degree>1
?
- std_cxx11::shared_ptr<const MappingQGeneric<dim,spacedim> >(dynamic_cast<MappingQGeneric<dim,spacedim>*>(mapping.qp_mapping->clone()))
+ std::shared_ptr<const MappingQGeneric<dim,spacedim> >(dynamic_cast<MappingQGeneric<dim,spacedim>*>(mapping.qp_mapping->clone()))
:
q1_mapping)
{}
#include <deal.II/base/quadrature_lib.h>
#include <deal.II/base/tensor_product_polynomials.h>
#include <deal.II/base/memory_consumption.h>
-#include <deal.II/base/std_cxx11/array.h>
-#include <deal.II/base/std_cxx11/unique_ptr.h>
#include <deal.II/lac/full_matrix.h>
#include <deal.II/grid/tria.h>
#include <deal.II/grid/tria_iterator.h>
#include <cmath>
#include <algorithm>
+#include <array>
+#include <memory>
DEAL_II_NAMESPACE_OPEN
//
// ---------------------------------------------------------------------
-#include <deal.II/base/std_cxx11/array.h>
#include <deal.II/fe/mapping_q1_eulerian.h>
#include <deal.II/lac/vector.h>
#include <deal.II/lac/block_vector.h>
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/fe/fe.h>
+
+#include <array>
+
DEAL_II_NAMESPACE_OPEN
template <int dim, class VectorType, int spacedim>
-std
_cxx11::array<Point<spacedim>, GeometryInfo<dim>::vertices_per_cell>
+std::array<Point<spacedim>, GeometryInfo<dim>::vertices_per_cell>
MappingQ1Eulerian<dim, VectorType, spacedim>::
get_vertices
(const typename Triangulation<dim,spacedim>::cell_iterator &cell) const
{
- std
_cxx11::array<Point<spacedim>, GeometryInfo<dim>::vertices_per_cell> vertices;
+ std::array<Point<spacedim>, GeometryInfo<dim>::vertices_per_cell> vertices;
// The assertions can not be in the constructor, since this would
// require to call dof_handler.distribute_dofs(fe) *before* the mapping
// object is constructed, which is not necessarily what we want.
MappingQ1Eulerian<dim,VectorType,spacedim>::
compute_mapping_support_points(const typename Triangulation<dim,spacedim>::cell_iterator &cell) const
{
- const std
_cxx11::array<Point<spacedim>, GeometryInfo<dim>::vertices_per_cell>
+ const std::array<Point<spacedim>, GeometryInfo<dim>::vertices_per_cell>
vertices = this->get_vertices(cell);
std::vector<Point<spacedim> > a(GeometryInfo<dim>::vertices_per_cell);
// .... COMPUTE MAPPING SUPPORT POINTS
template <int dim, class VectorType, int spacedim>
-std
_cxx11::array<Point<spacedim>, GeometryInfo<dim>::vertices_per_cell>
+std::array<Point<spacedim>, GeometryInfo<dim>::vertices_per_cell>
MappingQEulerian<dim, VectorType, spacedim>::
get_vertices
(const typename Triangulation<dim,spacedim>::cell_iterator &cell) const
const std::vector<Point<spacedim> > a
= dynamic_cast<const MappingQEulerianGeneric &>(*this->qp_mapping).compute_mapping_support_points(cell);
- std
_cxx11::array<Point<spacedim>, GeometryInfo<dim>::vertices_per_cell> vertex_locations;
+ std::array<Point<spacedim>, GeometryInfo<dim>::vertices_per_cell> vertex_locations;
std::copy (a.begin(),
a.begin()+GeometryInfo<dim>::vertices_per_cell,
vertex_locations.begin());
template <int dim, class VectorType, int spacedim>
-std
_cxx11::array<Point<spacedim>, GeometryInfo<dim>::vertices_per_cell>
+std::array<Point<spacedim>, GeometryInfo<dim>::vertices_per_cell>
MappingQEulerian<dim, VectorType, spacedim>::MappingQEulerianGeneric::
get_vertices
(const typename Triangulation<dim,spacedim>::cell_iterator &cell) const
#include <deal.II/base/quadrature_lib.h>
#include <deal.II/base/tensor_product_polynomials.h>
#include <deal.II/base/memory_consumption.h>
-#include <deal.II/base/std_cxx11/array.h>
-#include <deal.II/base/std_cxx11/unique_ptr.h>
#include <deal.II/lac/full_matrix.h>
#include <deal.II/grid/tria.h>
#include <deal.II/grid/tria_iterator.h>
#include <cmath>
#include <algorithm>
#include <numeric>
+#include <array>
+#include <memory>
DEAL_II_NAMESPACE_OPEN
template<int spacedim>
Point<1>
transform_real_to_unit_cell
- (const std
_cxx11::array<Point<spacedim>, GeometryInfo<1>::vertices_per_cell> &vertices,
+ (const std::array<Point<spacedim>, GeometryInfo<1>::vertices_per_cell> &vertices,
const Point<spacedim> &p)
{
Assert(spacedim == 1, ExcInternalError());
template<int spacedim>
Point<2>
transform_real_to_unit_cell
- (const std
_cxx11::array<Point<spacedim>, GeometryInfo<2>::vertices_per_cell> &vertices,
+ (const std::array<Point<spacedim>, GeometryInfo<2>::vertices_per_cell> &vertices,
const Point<spacedim> &p)
{
Assert(spacedim == 2, ExcInternalError());
template<int spacedim>
Point<3>
transform_real_to_unit_cell
- (const std
_cxx11::array<Point<spacedim>, GeometryInfo<3>::vertices_per_cell> &/*vertices*/,
+ (const std::array<Point<spacedim>, GeometryInfo<3>::vertices_per_cell> &/*vertices*/,
const Point<spacedim> &/*p*/)
{
// It should not be possible to get here
UpdateFlags update_flags = update_quadrature_points | update_jacobians;
if (spacedim>dim)
update_flags |= update_jacobian_grads;
- std_cxx11::unique_ptr<InternalData> mdata (get_data(update_flags,
- point_quadrature));
+ std::unique_ptr<InternalData> mdata (get_data(update_flags,
+ point_quadrature));
mdata->mapping_support_points = this->compute_mapping_support_points (cell);
UpdateFlags update_flags = update_quadrature_points | update_jacobians;
if (spacedim>dim)
update_flags |= update_jacobian_grads;
- std_cxx11::unique_ptr<InternalData> mdata (get_data(update_flags,
- point_quadrature));
+ std::unique_ptr<InternalData> mdata (get_data(update_flags,
+ point_quadrature));
mdata->mapping_support_points = this->compute_mapping_support_points (cell);
UpdateFlags update_flags = update_quadrature_points | update_jacobians;
if (spacedim>dim)
update_flags |= update_jacobian_grads;
- std_cxx11::unique_ptr<InternalData> mdata (get_data(update_flags,
- point_quadrature));
+ std::unique_ptr<InternalData> mdata (get_data(update_flags,
+ point_quadrature));
mdata->mapping_support_points = this->compute_mapping_support_points (cell);
UpdateFlags update_flags = update_quadrature_points | update_jacobians;
if (spacedim>dim)
update_flags |= update_jacobian_grads;
- std_cxx11::unique_ptr<InternalData> mdata (get_data(update_flags,
- point_quadrature));
+ std::unique_ptr<InternalData> mdata (get_data(update_flags,
+ point_quadrature));
mdata->mapping_support_points = this->compute_mapping_support_points (cell);
UpdateFlags update_flags = update_quadrature_points | update_jacobians;
if (spacedim>dim)
update_flags |= update_jacobian_grads;
- std_cxx11::unique_ptr<InternalData> mdata (get_data(update_flags,
- point_quadrature));
+ std::unique_ptr<InternalData> mdata (get_data(update_flags,
+ point_quadrature));
mdata->mapping_support_points = this->compute_mapping_support_points (cell);
// cell and that value is returned.
// * In 3D there is no (known to the authors) exact formula, so the Newton
// algorithm is used.
- const std
_cxx11::array<Point<spacedim>, GeometryInfo<dim>::vertices_per_cell>
+ const std::array<Point<spacedim>, GeometryInfo<dim>::vertices_per_cell>
vertices = this->get_vertices(cell);
try
{
const bool colorize)
{
Point<2> origin;
- std_cxx11::array<Tensor<1,2>,2> edges;
+ std::array<Tensor<1,2>,2> edges;
edges[0] = corners[0];
edges[1] = corners[1];
std::vector<unsigned int> subdivisions;
{
Point<dim> origin;
std::vector<unsigned int> subdivisions;
- std_cxx11::array<Tensor<1,dim>,dim> edges;
+ std::array<Tensor<1,dim>,dim> edges;
for (unsigned int i=0; i<dim; ++i)
{
subdivisions.push_back(n_subdivisions[i]);
void
subdivided_parallelepiped (Triangulation<dim, spacedim> &tria,
const Point<spacedim> &origin,
- const std_cxx11::array<Tensor<1,spacedim>,dim> &edges,
+ const std::array<Tensor<1,spacedim>,dim> &edges,
const std::vector<unsigned int> &subdivisions,
const bool colorize)
{
subdivided_parallelepiped<deal_II_dimension, deal_II_space_dimension>
(Triangulation<deal_II_dimension, deal_II_space_dimension> &,
const Point<deal_II_space_dimension> &,
- const std_cxx11::array<Tensor<1,deal_II_space_dimension>,deal_II_dimension> &,
+ const std::array<Tensor<1,deal_II_space_dimension>,deal_II_dimension> &,
const std::vector<unsigned int> &,
const bool colorize);
// if not put the whole thing
// back and return
if (std::find_if (line.begin(), line.end(),
- std_cxx11::bind (std::not_equal_to<char>(),std_cxx11::_1,' '))
+ std::bind (std::not_equal_to<char>(),std::placeholders::_1,' '))
!= line.end())
{
in.putback ('\n');
generate_triangulation_patches(patches, tria.begin_active(), tria.end());
DataOutBase::write_vtk (patches,
triangulation_patch_data_names(),
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> >(),
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> >(),
vtk_flags,
out);
generate_triangulation_patches(patches, tria.begin_active(), tria.end());
DataOutBase::write_vtu (patches,
triangulation_patch_data_names(),
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> >(),
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> >(),
vtu_flags,
out);
Utilities::int_to_string (tria.locally_owned_subdomain(), 4) +
".vtu");
std::ofstream out(new_file.c_str());
- std::vector<std_cxx1x::tuple<unsigned int, unsigned int, std::string> > vector_data_ranges;
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> > vector_data_ranges;
DataOutBase::VtkFlags flags;
DataOutBase::write_vtu (patches,
data_names,
#include <deal.II/grid/grid_reordering.h>
#include <deal.II/grid/grid_tools.h>
#include <deal.II/base/utilities.h>
-#include <deal.II/base/std_cxx11/bind.h>
#include <deal.II/base/timer.h>
#include <algorithm>
//
// ---------------------------------------------------------------------
-#include <deal.II/base/std_cxx11/array.h>
#include <deal.II/base/quadrature_lib.h>
#include <deal.II/base/thread_management.h>
#include <deal.II/lac/vector.h>
#include <boost/random/uniform_real_distribution.hpp>
#include <boost/random/mersenne_twister.hpp>
+#include <array>
#include <cmath>
#include <numeric>
#include <list>
std::vector<typename MeshType::active_cell_iterator>
compute_active_cell_halo_layer
(const MeshType &mesh,
- const std_cxx11::function<bool (const typename MeshType::active_cell_iterator &)> &predicate)
+ const std::function<bool (const typename MeshType::active_cell_iterator &)> &predicate)
{
std::vector<typename MeshType::active_cell_iterator> active_halo_layer;
std::vector<bool> locally_active_vertices_on_subdomain (mesh.get_triangulation().n_vertices(),
std::vector<typename MeshType::active_cell_iterator>
compute_ghost_cell_halo_layer (const MeshType &mesh)
{
- std_cxx11::function<bool (const typename MeshType::active_cell_iterator &)> predicate
+ std::function<bool (const typename MeshType::active_cell_iterator &)> predicate
= IteratorFilters::LocallyOwnedCell();
const std::vector<typename MeshType::active_cell_iterator>
unsigned int max_cellid_size = 0;
std::set<std::pair<types::subdomain_id,types::global_vertex_index> > vertices_added;
std::map<types::subdomain_id,std::set<unsigned int> > vertices_to_recv;
- std::map<types::subdomain_id,std::vector<std_cxx11::tuple<types::global_vertex_index,
+ std::map<types::subdomain_id,std::vector<std::tuple<types::global_vertex_index,
types::global_vertex_index,std::string> > > vertices_to_send;
active_cell_iterator cell = triangulation.begin_active(),
endc = triangulation.end();
if (vertices_added.find(tmp)==vertices_added.end())
{
vertices_to_send[(*adjacent_cell)->subdomain_id()].push_back(
- std_cxx11::tuple<types::global_vertex_index,types::global_vertex_index,
+ std::tuple<types::global_vertex_index,types::global_vertex_index,
std::string> (i,cell->vertex_index(i),
cell->id().to_string()));
if (cell->id().to_string().size() > max_cellid_size)
vertices_to_send.size());
std::vector<MPI_Request> first_requests(vertices_to_send.size());
typename std::map<types::subdomain_id,
- std::vector<std_cxx11::tuple<types::global_vertex_index,
+ std::vector<std::tuple<types::global_vertex_index,
types::global_vertex_index,std::string> > >::iterator
vert_to_send_it = vertices_to_send.begin(),
vert_to_send_end = vertices_to_send.end();
// fill the buffer
for (unsigned int j=0; j<n_vertices; ++j)
{
- vertices_send_buffers[i][2*j] = std_cxx11::get<0>(vert_to_send_it->second[j]);
+ vertices_send_buffers[i][2*j] = std::get<0>(vert_to_send_it->second[j]);
vertices_send_buffers[i][2*j+1] =
- local_to_global_vertex_index[std_cxx11::get<1>(vert_to_send_it->second[j])];
+ local_to_global_vertex_index[std::get<1>(vert_to_send_it->second[j])];
}
// Send the message
unsigned int pos = 0;
for (unsigned int j=0; j<n_vertices; ++j)
{
- std::string cell_id = std_cxx11::get<2>(vert_to_send_it->second[j]);
+ std::string cell_id = std::get<2>(vert_to_send_it->second[j]);
for (unsigned int k=0; k<max_cellid_size; ++k, ++pos)
{
if (k<cell_id.size())
template<> struct OrientationLookupTable<1>
{
- typedef std_cxx11::array<unsigned int, GeometryInfo<1>::vertices_per_face> MATCH_T;
+ typedef std::array<unsigned int, GeometryInfo<1>::vertices_per_face> MATCH_T;
static inline std::bitset<3> lookup (const MATCH_T &)
{
// The 1D case is trivial
template<> struct OrientationLookupTable<2>
{
- typedef std_cxx11::array<unsigned int, GeometryInfo<2>::vertices_per_face> MATCH_T;
+ typedef std::array<unsigned int, GeometryInfo<2>::vertices_per_face> MATCH_T;
static inline std::bitset<3> lookup (const MATCH_T &matching)
{
// In 2D matching faces (=lines) results in two cases: Either
template<> struct OrientationLookupTable<3>
{
- typedef std_cxx11::array<unsigned int, GeometryInfo<3>::vertices_per_face> MATCH_T;
+ typedef std::array<unsigned int, GeometryInfo<3>::vertices_per_face> MATCH_T;
static inline std::bitset<3> lookup (const MATCH_T &matching)
{
// The full fledged 3D case. *Yay*
// Do a full matching of the face vertices:
- std_cxx11::
+ std::
array<unsigned int, GeometryInfo<dim>::vertices_per_face> matching;
std::set<unsigned int> face2_vertices;
template
std::vector<dealii::internal::ActiveCellIterator<deal_II_dimension, deal_II_space_dimension, X>::type>
compute_active_cell_halo_layer (const X &,
- const std_cxx11::function<bool (const dealii::internal::ActiveCellIterator<deal_II_dimension, deal_II_space_dimension, X>::type&)> &);
+ const std::function<bool (const dealii::internal::ActiveCellIterator<deal_II_dimension, deal_II_space_dimension, X>::type&)> &);
template
std::vector<dealii::internal::ActiveCellIterator<deal_II_dimension, deal_II_space_dimension, X>::type>
#include <deal.II/base/memory_consumption.h>
#include <deal.II/base/table.h>
#include <deal.II/base/geometry_info.h>
-#include <deal.II/base/std_cxx11/bind.h>
#include <deal.II/grid/tria.h>
#include <deal.II/grid/tria_levels.h>
#include <list>
#include <cmath>
#include <functional>
+#include <array>
-#include <deal.II/base/std_cxx11/array.h>
DEAL_II_NAMESPACE_OPEN
// this file
std::map<internal::Triangulation::TriaObject<2>,
std::pair<typename Triangulation<dim,spacedim>::quad_iterator,
- std_cxx11::array<bool,GeometryInfo<dim>::lines_per_face> >,
+ std::array<bool,GeometryInfo<dim>::lines_per_face> >,
QuadComparator>
needed_quads;
for (unsigned int cell=0; cell<cells.size(); ++cell)
std::pair<int,int> line_list[GeometryInfo<dim>::lines_per_cell],
inverse_line_list[GeometryInfo<dim>::lines_per_cell];
unsigned int face_line_list[GeometryInfo<dim>::lines_per_face];
- std_cxx11::array<bool,GeometryInfo<dim>::lines_per_face> orientation;
+ std::array<bool,GeometryInfo<dim>::lines_per_face> orientation;
for (unsigned int line=0; line<GeometryInfo<dim>::lines_per_cell; ++line)
{
quad = triangulation.begin_raw_quad();
typename std::map<internal::Triangulation::TriaObject<2>,
std::pair<typename Triangulation<dim,spacedim>::quad_iterator,
- std_cxx11::array<bool,GeometryInfo<dim>::lines_per_face> >,
+ std::array<bool,GeometryInfo<dim>::lines_per_face> >,
QuadComparator>
::iterator q;
for (q = needed_quads.begin(); quad!=triangulation.end_quad(); ++quad, ++q)
const unsigned int used_cells
= std::count_if (triangulation.levels[level+1]->cells.used.begin(),
triangulation.levels[level+1]->cells.used.end(),
- std_cxx11::bind (std::equal_to<bool>(), std_cxx11::_1, true));
+ std::bind (std::equal_to<bool>(), std::placeholders::_1, true));
// reserve space for the used_cells cells already existing
// on the next higher level as well as for the
// vertices are already in use
needed_vertices += std::count_if (triangulation.vertices_used.begin(),
triangulation.vertices_used.end(),
- std_cxx11::bind (std::equal_to<bool>(),
- std_cxx11::_1,
- true));
+ std::bind (std::equal_to<bool>(),
+ std::placeholders::_1,
+ true));
// if we need more vertices: create them, if not: leave the
// array as is, since shrinking is not really possible because
// some of the vertices at the end may be in use
const unsigned int used_cells
= std::count_if (triangulation.levels[level+1]->cells.used.begin(),
triangulation.levels[level+1]->cells.used.end(),
- std_cxx11::bind (std::equal_to<bool>(), std_cxx11::_1, true));
+ std::bind (std::equal_to<bool>(), std::placeholders::_1, true));
// reserve space for the used_cells cells already existing
// add to needed vertices how many vertices are already in use
needed_vertices += std::count_if (triangulation.vertices_used.begin(), triangulation.vertices_used.end(),
- std_cxx11::bind (std::equal_to<bool>(), std_cxx11::_1, true));
+ std::bind (std::equal_to<bool>(), std::placeholders::_1, true));
// if we need more vertices: create them, if not: leave the
// array as is, since shrinking is not really possible because
// some of the vertices at the end may be in use
const unsigned int used_cells
= std::count_if (triangulation.levels[level+1]->cells.used.begin(),
triangulation.levels[level+1]->cells.used.end(),
- std_cxx11::bind (std::equal_to<bool>(), std_cxx11::_1, true));
+ std::bind (std::equal_to<bool>(), std::placeholders::_1, true));
// reserve space for the used_cells cells already existing
// add to needed vertices how many vertices are already in use
needed_vertices += std::count_if (triangulation.vertices_used.begin(), triangulation.vertices_used.end(),
- std_cxx11::bind (std::equal_to<bool>(), std_cxx11::_1, true));
+ std::bind (std::equal_to<bool>(), std::placeholders::_1, true));
// if we need more vertices: create them, if not: leave the
// array as is, since shrinking is not really possible because
// some of the vertices at the end may be in use
Triangulation<dim, spacedim>::n_used_vertices () const
{
return std::count_if (vertices_used.begin(), vertices_used.end(),
- std_cxx11::bind (std::equal_to<bool>(), std_cxx11::_1, true));
+ std::bind (std::equal_to<bool>(), std::placeholders::_1, true));
}
#include <deal.II/grid/tria_accessor.h>
#include <deal.II/grid/tria_accessor.templates.h>
#include <deal.II/grid/tria_iterator.templates.h>
-#include <deal.II/base/std_cxx11/array.h>
#include <deal.II/base/geometry_info.h>
#include <deal.II/base/quadrature.h>
#include <deal.II/grid/grid_tools.h>
#include <deal.II/fe/mapping_q1.h>
#include <deal.II/fe/fe_q.h>
+#include <array>
#include <cmath>
DEAL_II_NAMESPACE_OPEN
CellId
CellAccessor<dim,spacedim>::id() const
{
- std_cxx11::array<unsigned char,30> id;
+ std::array<unsigned char,30> id;
CellAccessor<dim,spacedim> ptr = *this;
const unsigned int n_child_indices = ptr.level();
// another thread might have created points in the meantime
if (points[n_intermediate_points].get() == 0)
{
- std_cxx11::shared_ptr<QGaussLobatto<1> >
+ std::shared_ptr<QGaussLobatto<1> >
quadrature (new QGaussLobatto<1>(n_intermediate_points+2));
points[n_intermediate_points] = quadrature;
}
// ---------------------------------------------------------------------
#include <deal.II/base/memory_consumption.h>
-#include <deal.II/base/std_cxx11/bind.h>
#include <deal.II/grid/tria_objects.h>
#include <deal.II/grid/tria.h>
#include <deal.II/grid/tria_iterator.h>
const unsigned int new_size = new_hexes +
std::count_if (used.begin(),
used.end(),
- std_cxx11::bind (std::equal_to<bool>(), std_cxx11::_1, true));
+ std::bind (std::equal_to<bool>(), std::placeholders::_1, true));
// see above...
if (new_size>cells.size())
#include <deal.II/base/memory_consumption.h>
#include <deal.II/base/geometry_info.h>
#include <deal.II/base/thread_management.h>
-#include <deal.II/base/std_cxx11/bind.h>
#include <deal.II/hp/dof_handler.h>
#include <deal.II/hp/dof_level.h>
#include <deal.II/hp/dof_faces.h>
void
ensure_existence_of_dof_identities (const FiniteElement<dim,spacedim> &fe1,
const FiniteElement<dim,spacedim> &fe2,
- std_cxx11::shared_ptr<DoFIdentities> &identities)
+ std::shared_ptr<DoFIdentities> &identities)
{
// see if we need to fill this
// entry, or whether it already
case 0:
{
identities =
- std_cxx11::shared_ptr<DoFIdentities>
+ std::shared_ptr<DoFIdentities>
(new DoFIdentities(fe1.hp_vertex_dof_identities(fe2)));
break;
}
case 1:
{
identities =
- std_cxx11::shared_ptr<DoFIdentities>
+ std::shared_ptr<DoFIdentities>
(new DoFIdentities(fe1.hp_line_dof_identities(fe2)));
break;
}
case 2:
{
identities =
- std_cxx11::shared_ptr<DoFIdentities>
+ std::shared_ptr<DoFIdentities>
(new DoFIdentities(fe1.hp_quad_dof_identities(fe2)));
break;
}
tria_listeners.push_back
(tria.signals.pre_refinement
- .connect (std_cxx11::bind (&DoFHandler<dim,spacedim>::pre_refinement_action,
- std_cxx11::ref(*this))));
+ .connect (std::bind (&DoFHandler<dim,spacedim>::pre_refinement_action,
+ std::ref(*this))));
tria_listeners.push_back
(tria.signals.post_refinement
- .connect (std_cxx11::bind (&DoFHandler<dim,spacedim>::post_refinement_action,
- std_cxx11::ref(*this))));
+ .connect (std::bind (&DoFHandler<dim,spacedim>::post_refinement_action,
+ std::ref(*this))));
tria_listeners.push_back
(tria.signals.create
- .connect (std_cxx11::bind (&DoFHandler<dim,spacedim>::post_refinement_action,
- std_cxx11::ref(*this))));
+ .connect (std::bind (&DoFHandler<dim,spacedim>::post_refinement_action,
+ std::ref(*this))));
}
// vertices at all, I can't think
// of a finite element that would
// make that necessary...
- Table<2,std_cxx11::shared_ptr<dealii::internal::hp::DoFIdentities> >
+ Table<2,std::shared_ptr<dealii::internal::hp::DoFIdentities> >
vertex_dof_identities (get_fe().size(),
get_fe().size());
// is to first treat all pairs of finite elements that have *identical* dofs,
// and then only deal with those that are not identical of which we can
// handle at most 2
- Table<2,std_cxx11::shared_ptr<internal::hp::DoFIdentities> >
+ Table<2,std::shared_ptr<internal::hp::DoFIdentities> >
line_dof_identities (finite_elements->size(),
finite_elements->size());
// for quads only in 4d and
// higher, so this isn't a
// particularly frequent case
- Table<2,std_cxx11::shared_ptr<internal::hp::DoFIdentities> >
+ Table<2,std::shared_ptr<internal::hp::DoFIdentities> >
quad_dof_identities (finite_elements->size(),
finite_elements->size());
std::transform (tria->levels[i]->cells.children.begin (),
tria->levels[i]->cells.children.end (),
has_children_level->begin (),
- std_cxx11::bind(std::not_equal_to<int>(),
- std_cxx11::_1,
- -1));
+ std::bind(std::not_equal_to<int>(),
+ std::placeholders::_1,
+ -1));
else
std::transform (tria->levels[i]->cells.refinement_cases.begin (),
tria->levels[i]->cells.refinement_cases.end (),
has_children_level->begin (),
- std_cxx11::bind (std::not_equal_to<unsigned char>(),
- std_cxx11::_1,
- static_cast<unsigned char>(RefinementCase<dim>::no_refinement)));
+ std::bind (std::not_equal_to<unsigned char>(),
+ std::placeholders::_1,
+ static_cast<unsigned char>(RefinementCase<dim>::no_refinement)));
has_children.push_back (has_children_level);
}
"same number of vector components!"));
finite_elements
- .push_back (std_cxx11::shared_ptr<const FiniteElement<dim,spacedim> >(new_fe.clone()));
+ .push_back (std::shared_ptr<const FiniteElement<dim,spacedim> >(new_fe.clone()));
}
if (fe_values_table(present_fe_values_index).get() == 0)
fe_values_table(present_fe_values_index)
=
- std_cxx11::shared_ptr<FEValuesType>
+ std::shared_ptr<FEValuesType>
(new FEValuesType ((*mapping_collection)[mapping_index],
(*fe_collection)[fe_index],
q_collection[q_index],
MappingCollection (const Mapping<dim,spacedim> &mapping)
{
mappings
- .push_back (std_cxx11::shared_ptr<const Mapping<dim,spacedim> >(mapping.clone()));
+ .push_back (std::shared_ptr<const Mapping<dim,spacedim> >(mapping.clone()));
}
MappingCollection<dim,spacedim>::push_back (const Mapping<dim,spacedim> &new_mapping)
{
mappings
- .push_back (std_cxx11::shared_ptr<const Mapping<dim,spacedim> >(new_mapping.clone()));
+ .push_back (std::shared_ptr<const Mapping<dim,spacedim> >(new_mapping.clone()));
}
//---------------------------------------------------------------------------
template <typename Number>
void Vector<Number>::import(const ReadWriteVector<Number> &V,
VectorOperation::values operation,
- std_cxx11::shared_ptr<const CommunicationPatternBase> )
+ std::shared_ptr<const CommunicationPatternBase> )
{
if (operation == VectorOperation::insert)
{
const std::size_t nonzero_elements
= std::count_if (&colnums[rowstart[0]],
&colnums[rowstart[rows]],
- std_cxx11::bind(std::not_equal_to<size_type>(), std_cxx11::_1, invalid_entry));
+ std::bind(std::not_equal_to<size_type>(), std::placeholders::_1, invalid_entry));
// now allocate the respective memory
size_type *new_colnums = new size_type[nonzero_elements];
#ifdef DEAL_II_WITH_MPI
#include <deal.II/base/index_set.h>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
#include "Epetra_Map.h"
+#include <memory>
DEAL_II_NAMESPACE_OPEN
const IndexSet &read_write_vector_index_set,
const MPI_Comm &communicator)
{
- comm = std_cxx11::make_shared<const MPI_Comm>(communicator);
+ comm = std::make_shared<const MPI_Comm>(communicator);
Epetra_Map vector_space_vector_map = vector_space_vector_index_set.make_trilinos_map(*comm,
false);
void Vector::import(const ReadWriteVector<double> &V,
VectorOperation::values operation,
- std_cxx11::shared_ptr<const CommunicationPatternBase> communication_pattern)
+ std::shared_ptr<const CommunicationPatternBase> communication_pattern)
{
// If no communication pattern is given, create one. Otherwsie, use the
// one given.
else
{
epetra_comm_pattern =
- std_cxx11::dynamic_pointer_cast<const CommunicationPattern> (communication_pattern);
+ std::dynamic_pointer_cast<const CommunicationPattern> (communication_pattern);
AssertThrow(epetra_comm_pattern != NULL,
ExcMessage(std::string("The communication pattern is not of type ") +
"LinearAlgebra::EpetraWrappers::CommunicationPattern."));
private:
double initial_residual;
double current_residual;
- std
_cxx11::shared_ptr<AztecOO_StatusTestCombo> status_test_collection;
- std
_cxx11::shared_ptr<AztecOO_StatusTestMaxIters> status_test_max_steps;
- std
_cxx11::shared_ptr<AztecOO_StatusTestResNorm> status_test_abs_tol;
- std
_cxx11::shared_ptr<AztecOO_StatusTestResNorm> status_test_rel_tol;
+ std::shared_ptr<AztecOO_StatusTestCombo> status_test_collection;
+ std::shared_ptr<AztecOO_StatusTestMaxIters> status_test_max_steps;
+ std::shared_ptr<AztecOO_StatusTestResNorm> status_test_abs_tol;
+ std::shared_ptr<AztecOO_StatusTestResNorm> status_test_rel_tol;
};
const Epetra_Map &input_col_map,
const SparsityPatternType &sparsity_pattern,
const bool exchange_data,
- std_cxx11::shared_ptr<Epetra_Map> &column_space_map,
- std_cxx11::shared_ptr<Epetra_FECrsMatrix> &matrix,
- std_cxx11::shared_ptr<Epetra_CrsMatrix> &nonlocal_matrix,
- std_cxx11::shared_ptr<Epetra_Export> &nonlocal_matrix_exporter)
+ std::shared_ptr<Epetra_Map> &column_space_map,
+ std::shared_ptr<Epetra_FECrsMatrix> &matrix,
+ std::shared_ptr<Epetra_CrsMatrix> &nonlocal_matrix,
+ std::shared_ptr<Epetra_Export> &nonlocal_matrix_exporter)
{
// release memory before reallocation
matrix.reset();
// col_map that tells how the domain dofs of the matrix will be
// distributed). for only one processor, we can directly assign the
// columns as well. Compare this with bug # 4123 in the Sandia Bugzilla.
- std_cxx11::shared_ptr<Epetra_CrsGraph> graph;
+ std::shared_ptr<Epetra_CrsGraph> graph;
if (input_row_map.Comm().NumProc() > 1)
graph.reset (new Epetra_CrsGraph (Copy, input_row_map,
&n_entries_per_row[0], true));
const Epetra_Map &input_col_map,
const DynamicSparsityPattern &sparsity_pattern,
const bool exchange_data,
- std_cxx11::shared_ptr<Epetra_Map> &column_space_map,
- std_cxx11::shared_ptr<Epetra_FECrsMatrix> &matrix,
- std_cxx11::shared_ptr<Epetra_CrsMatrix> &nonlocal_matrix,
- std_cxx11::shared_ptr<Epetra_Export> &nonlocal_matrix_exporter)
+ std::shared_ptr<Epetra_Map> &column_space_map,
+ std::shared_ptr<Epetra_FECrsMatrix> &matrix,
+ std::shared_ptr<Epetra_CrsMatrix> &nonlocal_matrix,
+ std::shared_ptr<Epetra_Export> &nonlocal_matrix_exporter)
{
matrix.reset();
nonlocal_matrix.reset();
(ghost_rows.size()>0)?(&ghost_rows[0]):NULL,
0, input_row_map.Comm());
- std_cxx11::shared_ptr<Epetra_CrsGraph> graph;
- std_cxx11::shared_ptr<Epetra_CrsGraphMod> nonlocal_graph;
+ std::shared_ptr<Epetra_CrsGraph> graph;
+ std::shared_ptr<Epetra_CrsGraphMod> nonlocal_graph;
if (input_row_map.Comm().NumProc() > 1)
{
graph.reset (new Epetra_CrsGraph (Copy, input_row_map,
reinit_sp (const Epetra_Map &row_map,
const Epetra_Map &col_map,
const size_type n_entries_per_row,
- std_cxx11::shared_ptr<Epetra_Map> &column_space_map,
- std_cxx11::shared_ptr<Epetra_FECrsGraph> &graph,
- std_cxx11::shared_ptr<Epetra_CrsGraph> &nonlocal_graph)
+ std::shared_ptr<Epetra_Map> &column_space_map,
+ std::shared_ptr<Epetra_FECrsGraph> &graph,
+ std::shared_ptr<Epetra_CrsGraph> &nonlocal_graph)
{
Assert(row_map.IsOneToOne(),
ExcMessage("Row map must be 1-to-1, i.e., no overlap between "
reinit_sp (const Epetra_Map &row_map,
const Epetra_Map &col_map,
const std::vector<size_type> &n_entries_per_row,
- std_cxx11::shared_ptr<Epetra_Map> &column_space_map,
- std_cxx11::shared_ptr<Epetra_FECrsGraph> &graph,
- std_cxx11::shared_ptr<Epetra_CrsGraph> &nonlocal_graph)
+ std::shared_ptr<Epetra_Map> &column_space_map,
+ std::shared_ptr<Epetra_FECrsGraph> &graph,
+ std::shared_ptr<Epetra_CrsGraph> &nonlocal_graph)
{
Assert(row_map.IsOneToOne(),
ExcMessage("Row map must be 1-to-1, i.e., no overlap between "
const Epetra_Map &col_map,
const SparsityPatternType &sp,
const bool exchange_data,
- std_cxx11::shared_ptr<Epetra_Map> &column_space_map,
- std_cxx11::shared_ptr<Epetra_FECrsGraph> &graph,
- std_cxx11::shared_ptr<Epetra_CrsGraph> &nonlocal_graph)
+ std::shared_ptr<Epetra_Map> &column_space_map,
+ std::shared_ptr<Epetra_FECrsGraph> &graph,
+ std::shared_ptr<Epetra_CrsGraph> &nonlocal_graph)
{
nonlocal_graph.reset ();
graph.reset ();
Epetra_Map new_map (v.size(), n_elements, &global_ids[0], 0,
v.block(0).vector_partitioner().Comm());
- std_cxx11::shared_ptr<Epetra_FEVector> actual_vec;
+ std::shared_ptr<Epetra_FEVector> actual_vec;
if ( import_data == true )
actual_vec.reset (new Epetra_FEVector (new_map));
else
for (unsigned int i=0; i<n_levels-1; ++i)
{
prolongation_sparsities
- .push_back (std_cxx11::shared_ptr<BlockSparsityPattern> (new BlockSparsityPattern));
+ .push_back (std::shared_ptr<BlockSparsityPattern> (new BlockSparsityPattern));
prolongation_matrices
- .push_back (std_cxx11::shared_ptr<BlockSparseMatrix<double> > (new BlockSparseMatrix<double>));
+ .push_back (std::shared_ptr<BlockSparseMatrix<double> > (new BlockSparseMatrix<double>));
}
// two fields which will store the
// copy_indices.
const types::global_dof_index n_active_dofs =
std::count_if (temp_copy_indices.begin(), temp_copy_indices.end(),
- std_cxx11::bind (std::not_equal_to<types::global_dof_index>(),
- std_cxx11::_1,
- numbers::invalid_dof_index));
+ std::bind (std::not_equal_to<types::global_dof_index>(),
+ std::placeholders::_1,
+ numbers::invalid_dof_index));
copy_indices[selected_block][level].resize (n_active_dofs);
types::global_dof_index counter = 0;
for (types::global_dof_index i=0; i<temp_copy_indices.size(); ++i)
const types::global_dof_index n_active_dofs =
std::count_if (temp_copy_indices[block].begin(),
temp_copy_indices[block].end(),
- std_cxx11::bind (std::not_equal_to<types::global_dof_index>(),
- std_cxx11::_1,
- numbers::invalid_dof_index));
+ std::bind (std::not_equal_to<types::global_dof_index>(),
+ std::placeholders::_1,
+ numbers::invalid_dof_index));
copy_indices[block][level].resize (n_active_dofs);
types::global_dof_index counter = 0;
for (types::global_dof_index i=0; i<temp_copy_indices[block].size(); ++i)
for (unsigned int i=0; i<n_levels-1; ++i)
{
prolongation_sparsities
- .push_back (std_cxx11::shared_ptr<BlockSparsityPattern> (new BlockSparsityPattern));
+ .push_back (std::shared_ptr<BlockSparsityPattern> (new BlockSparsityPattern));
prolongation_matrices
- .push_back (std_cxx11::shared_ptr<BlockSparseMatrix<double> > (new BlockSparseMatrix<double>));
+ .push_back (std::shared_ptr<BlockSparseMatrix<double> > (new BlockSparseMatrix<double>));
}
// two fields which will store the
// global to level dofs
const types::global_dof_index n_active_dofs =
std::count_if (temp_copy_indices.begin(), temp_copy_indices.end(),
- std_cxx11::bind (std::not_equal_to<types::global_dof_index>(),
- std_cxx11::_1,
- numbers::invalid_dof_index));
+ std::bind (std::not_equal_to<types::global_dof_index>(),
+ std::placeholders::_1,
+ numbers::invalid_dof_index));
copy_to_and_from_indices[level].resize (n_active_dofs);
types::global_dof_index counter = 0;
for (types::global_dof_index i=0; i<temp_copy_indices.size(); ++i)
{
// shift the local number of the copy indices according to the new
// partitioner that we are going to use for the vector
- const std_cxx11::shared_ptr<const Utilities::MPI::Partitioner> part
+ const std::shared_ptr<const Utilities::MPI::Partitioner> part
= ghosted_level_vector.get_partitioner();
ghosted_dofs.add_indices(part->ghost_indices());
for (unsigned int i=0; i<copy_indices_global_mine.size(); ++i)
ExcInternalError());
fe_name[template_starts+1] = '1';
}
- std_cxx11::shared_ptr<FiniteElement<1> > fe_1d
+ std::shared_ptr<FiniteElement<1> > fe_1d
(FETools::get_fe_by_name<1,1>(fe_name));
const FiniteElement<1> &fe = *fe_1d;
for (unsigned int i=0; i<n_levels-1; ++i)
{
prolongation_sparsities.push_back
- (std_cxx11::shared_ptr<typename internal::MatrixSelector<VectorType>::Sparsity> (new typename internal::MatrixSelector<VectorType>::Sparsity));
+ (std::shared_ptr<typename internal::MatrixSelector<VectorType>::Sparsity> (new typename internal::MatrixSelector<VectorType>::Sparsity));
prolongation_matrices.push_back
- (std_cxx11::shared_ptr<typename internal::MatrixSelector<VectorType>::Matrix> (new typename internal::MatrixSelector<VectorType>::Matrix));
+ (std::shared_ptr<typename internal::MatrixSelector<VectorType>::Matrix> (new typename internal::MatrixSelector<VectorType>::Matrix));
}
// two fields which will store the
const unsigned int n_subdivisions,
const std::vector<unsigned int> &n_postprocessor_outputs,
const Mapping<dim,spacedim> &mapping,
- const std::vector<std_cxx11::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > &finite_elements,
+ const std::vector<std::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > &finite_elements,
const UpdateFlags update_flags,
const std::vector<std::vector<unsigned int> > &cell_to_patch_index_map)
:
if (all_cells.size() > 0)
WorkStream::run (&all_cells[0],
&all_cells[0]+all_cells.size(),
- std_cxx11::bind(&DataOut<dim,DoFHandlerType>::build_one_patch,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- /* no std_cxx11::_3, since this function doesn't actually need a
- copy data object -- it just writes everything right into the
- output array */
- n_subdivisions,
- curved_cell_region),
+ std::bind(&DataOut<dim,DoFHandlerType>::build_one_patch,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ /* no std::placeholders::_3, since this function doesn't actually need a
+ copy data object -- it just writes everything right into the
+ output array */
+ n_subdivisions,
+ curved_cell_region),
// no copy-local-to-global function needed here
- std_cxx11::function<void (const int &)>(),
+ std::function<void (const int &)>(),
thread_data,
/* dummy CopyData object = */ 0,
// experimenting shows that we can make things run a bit
const unsigned int n_subdivisions,
const std::vector<unsigned int> &n_postprocessor_outputs,
const Mapping<dim,spacedim> &mapping,
- const std::vector<std_cxx11::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > &finite_elements,
+ const std::vector<std::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > &finite_elements,
const UpdateFlags update_flags,
const bool use_face_values)
:
template <typename DoFHandlerType>
void
ParallelDataBase<dim,spacedim>::
- reinit_all_fe_values(std::vector<std_cxx11::shared_ptr<DataEntryBase<DoFHandlerType> > > &dof_data,
+ reinit_all_fe_values(std::vector<std::shared_ptr<DataEntryBase<DoFHandlerType> > > &dof_data,
const typename dealii::Triangulation<dim,spacedim>::cell_iterator &cell,
const unsigned int face)
{
= new internal::DataOut::DataEntry<DoFHandlerType,VectorType>(dofs, &vec, names,
data_component_interpretation);
if (actual_type == type_dof_data)
- dof_data.push_back (std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DoFHandlerType> >(new_entry));
+ dof_data.push_back (std::shared_ptr<internal::DataOut::DataEntryBase<DoFHandlerType> >(new_entry));
else
- cell_data.push_back (std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DoFHandlerType> >(new_entry));
+ cell_data.push_back (std::shared_ptr<internal::DataOut::DataEntryBase<DoFHandlerType> >(new_entry));
}
internal::DataOut::DataEntryBase<DoFHandlerType> *new_entry
= new internal::DataOut::DataEntry<DoFHandlerType,VectorType>(dofs, &vec, &data_postprocessor);
- dof_data.push_back (std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DoFHandlerType> >(new_entry));
+ dof_data.push_back (std::shared_ptr<internal::DataOut::DataEntryBase<DoFHandlerType> >(new_entry));
}
internal::DataOut::DataEntryBase<DoFHandlerType> *new_entry
= new internal::DataOut::DataEntry<DoFHandlerType,VectorType>(&dof_handler, &vec, &data_postprocessor);
- dof_data.push_back (std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DoFHandlerType> >(new_entry));
+ dof_data.push_back (std::shared_ptr<internal::DataOut::DataEntryBase<DoFHandlerType> >(new_entry));
}
internal::DataOut::DataEntryBase<DoFHandlerType> *new_entry
= new internal::DataOut::DataEntry<DoFHandlerType,VectorType>(&dof_handler, &data, names,
data_component_interpretation);
- dof_data.push_back (std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DoFHandlerType> >(new_entry));
+ dof_data.push_back (std::shared_ptr<internal::DataOut::DataEntryBase<DoFHandlerType> >(new_entry));
}
// collect the names of dof
// and cell data
typedef
- typename std::vector<std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DoFHandlerType> > >::const_iterator
+ typename std::vector<std::shared_ptr<internal::DataOut::DataEntryBase<DoFHandlerType> > >::const_iterator
data_iterator;
for (data_iterator d=dof_data.begin();
template <typename DoFHandlerType,
int patch_dim, int patch_space_dim>
-std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> >
+std::vector<std::tuple<unsigned int, unsigned int, std::string> >
DataOut_DoFData<DoFHandlerType,patch_dim,patch_space_dim>::get_vector_data_ranges () const
{
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> >
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> >
ranges;
// collect the ranges of dof
// and cell data
typedef
- typename std::vector<std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DoFHandlerType> > >::const_iterator
+ typename std::vector<std::shared_ptr<internal::DataOut::DataEntryBase<DoFHandlerType> > >::const_iterator
data_iterator;
unsigned int output_component = 0;
// finally add a corresponding
// range
- std_cxx11::tuple<unsigned int, unsigned int, std::string>
+ std::tuple<unsigned int, unsigned int, std::string>
range (output_component,
output_component+patch_space_dim-1,
name);
template <typename DoFHandlerType,
int patch_dim, int patch_space_dim>
-std::vector<std_cxx11::shared_ptr<dealii::hp::FECollection<DoFHandlerType::dimension,
+std::vector<std::shared_ptr<dealii::hp::FECollection<DoFHandlerType::dimension,
DoFHandlerType::space_dimension> > >
DataOut_DoFData<DoFHandlerType,patch_dim,patch_space_dim>::get_finite_elements() const
{
const unsigned int dhdim = DoFHandlerType::dimension;
const unsigned int dhspacedim = DoFHandlerType::space_dimension;
- std::vector<std_cxx11::shared_ptr<dealii::hp::FECollection<dhdim,dhspacedim> > >
+ std::vector<std::shared_ptr<dealii::hp::FECollection<dhdim,dhspacedim> > >
finite_elements(this->dof_data.size());
for (unsigned int i=0; i<this->dof_data.size(); ++i)
{
void
ParallelDataBase<deal_II_dimension,deal_II_space_dimension>::
reinit_all_fe_values<dealii::DH<deal_II_dimension,deal_II_space_dimension> >
- (std::vector<std_cxx11::shared_ptr<DataEntryBase<dealii::DH<deal_II_dimension,deal_II_space_dimension> > > > &dof_data,
+ (std::vector<std::shared_ptr<DataEntryBase<dealii::DH<deal_II_dimension,deal_II_space_dimension> > > > &dof_data,
const dealii::Triangulation<deal_II_dimension,deal_II_space_dimension>::cell_iterator &cell,
const unsigned int face);
#endif
const unsigned int n_subdivisions,
const std::vector<unsigned int> &n_postprocessor_outputs,
const Mapping<dim,spacedim> &mapping,
- const std::vector<std_cxx11::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > &finite_elements,
+ const std::vector<std::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > &finite_elements,
const UpdateFlags update_flags)
:
internal::DataOut::
// now build the patches in parallel
WorkStream::run (&all_faces[0],
&all_faces[0]+all_faces.size(),
- std_cxx11::bind(&DataOutFaces<dim,DoFHandlerType>::build_one_patch,
- this, std_cxx11::_1, std_cxx11::_2, std_cxx11::_3),
- std_cxx11::bind(&internal::DataOutFaces::
- append_patch_to_list<dim,space_dimension>,
- std_cxx11::_1, std_cxx11::ref(this->patches)),
+ std::bind(&DataOutFaces<dim,DoFHandlerType>::build_one_patch,
+ this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3),
+ std::bind(&internal::DataOutFaces::
+ append_patch_to_list<dim,space_dimension>,
+ std::placeholders::_1, std::ref(this->patches)),
thread_data,
sample_patch);
}
const unsigned int n_patches_per_circle,
const std::vector<unsigned int> &n_postprocessor_outputs,
const Mapping<dim,spacedim> &mapping,
- const std::vector<std_cxx11::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > &finite_elements,
+ const std::vector<std::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > &finite_elements,
const UpdateFlags update_flags)
:
internal::DataOut::
// now build the patches in parallel
WorkStream::run (&all_cells[0],
&all_cells[0]+all_cells.size(),
- std_cxx11::bind(&DataOutRotation<dim,DoFHandlerType>::build_one_patch,
- this, std_cxx11::_1, std_cxx11::_2, std_cxx11::_3),
- std_cxx11::bind(&internal::DataOutRotation
- ::append_patch_to_list<dim,space_dimension>,
- std_cxx11::_1, std_cxx11::ref(this->patches)),
+ std::bind(&DataOutRotation<dim,DoFHandlerType>::build_one_patch,
+ this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3),
+ std::bind(&internal::DataOutRotation
+ ::append_patch_to_list<dim,space_dimension>,
+ std::placeholders::_1, std::ref(this->patches)),
thread_data,
new_patches);
}
template <int, int> class DoFHandlerType, class InputVector, int spacedim>
void
approximate
- (SynchronousIterators<std_cxx11::tuple<TriaActiveIterator < dealii::DoFCellAccessor < DoFHandlerType < dim, spacedim >, false > >, Vector<float>::iterator> > const &cell,
+ (SynchronousIterators<std::tuple<TriaActiveIterator < dealii::DoFCellAccessor < DoFHandlerType < dim, spacedim >, false > >, Vector<float>::iterator> > const &cell,
const Mapping<dim,spacedim> &mapping,
const DoFHandlerType<dim,spacedim> &dof_handler,
const InputVector &solution,
const unsigned int component)
{
// if the cell is not locally owned, then there is nothing to do
- if (std_cxx11::get<0>(*cell)->is_locally_owned() == false)
- *std_cxx11::get<1>(*cell) = 0;
+ if (std::get<0>(*cell)->is_locally_owned() == false)
+ *std::get<1>(*cell) = 0;
else
{
typename DerivativeDescription::Derivative derivative;
// call the function doing the actual
// work on this cell
approximate_cell<DerivativeDescription,dim,DoFHandlerType,InputVector, spacedim>
- (mapping,dof_handler,solution,component,std_cxx11::get<0>(*cell),derivative);
+ (mapping,dof_handler,solution,component,std::get<0>(*cell),derivative);
// evaluate the norm and fill the vector
//*derivative_norm_on_this_cell
- *std_cxx11::get<1>(*cell) = DerivativeDescription::derivative_norm (derivative);
+ *std::get<1>(*cell) = DerivativeDescription::derivative_norm (derivative);
}
}
Assert (component < dof_handler.get_fe().n_components(),
ExcIndexRange (component, 0, dof_handler.get_fe().n_components()));
- typedef std_cxx11::tuple<TriaActiveIterator<dealii::DoFCellAccessor
+ typedef std::tuple<TriaActiveIterator<dealii::DoFCellAccessor
<DoFHandlerType<dim, spacedim>, false> >,
Vector<float>::iterator> Iterators;
SynchronousIterators<Iterators> begin(Iterators(dof_handler.begin_active(),
// to write in derivative_norm. Scratch and CopyData are also useless.
WorkStream::run(begin,
end,
- static_cast<std_cxx11::function<void (SynchronousIterators<Iterators> const &,
- Assembler::Scratch const &, Assembler::CopyData &)> >
- (std_cxx11::bind(&approximate<DerivativeDescription,dim,DoFHandlerType,
- InputVector,spacedim>,
- std_cxx11::_1,
- std_cxx11::cref(mapping),
- std_cxx11::cref(dof_handler),
- std_cxx11::cref(solution),component)),
- std_cxx11::function<void (internal::Assembler::CopyData const &)> (),
+ static_cast<std::function<void (SynchronousIterators<Iterators> const &,
+ Assembler::Scratch const &, Assembler::CopyData &)> >
+ (std::bind(&approximate<DerivativeDescription,dim,DoFHandlerType,
+ InputVector,spacedim>,
+ std::placeholders::_1,
+ std::cref(mapping),
+ std::cref(dof_handler),
+ std::cref(solution),component)),
+ std::function<void (internal::Assembler::CopyData const &)> (),
internal::Assembler::Scratch (),internal::Assembler::CopyData ());
}
#include <deal.II/numerics/error_estimator.h>
#include <deal.II/distributed/tria.h>
-#include <deal.II/base/std_cxx11/bind.h>
#include <numeric>
#include <algorithm>
#include <cmath>
#include <vector>
+#include <functional>
DEAL_II_NAMESPACE_OPEN
= std::vector<std::vector <double> > (n_indep, std::vector <double> (0));
indep_names = std::vector <std::string> ();
- tria_listener = dof_handler.get_triangulation().signals.any_change.connect (std_cxx11::bind (&PointValueHistory<dim>::tria_change_listener,
- std_cxx11::ref(*this)));
+ tria_listener = dof_handler.get_triangulation().signals.any_change.connect (std::bind (&PointValueHistory<dim>::tria_change_listener,
+ std::ref(*this)));
}
// Presume subscribe new instance?
if (have_dof_handler)
{
- tria_listener = dof_handler->get_triangulation().signals.any_change.connect (std_cxx11::bind (&PointValueHistory<dim>::tria_change_listener,
- std_cxx11::ref(*this)));
+ tria_listener = dof_handler->get_triangulation().signals.any_change.connect (std::bind (&PointValueHistory<dim>::tria_change_listener,
+ std::ref(*this)));
}
}
// Presume subscribe new instance?
if (have_dof_handler)
{
- tria_listener = dof_handler->get_triangulation().signals.any_change.connect (std_cxx11::bind (&PointValueHistory<dim>::tria_change_listener,
- std_cxx11::ref(*this)));
+ tria_listener = dof_handler->get_triangulation().signals.any_change.connect (std::bind (&PointValueHistory<dim>::tria_change_listener,
+ std::ref(*this)));
}
return * this;
#include <deal.II/base/thread_management.h>
#include <deal.II/base/utilities.h>
#include <deal.II/base/parallel.h>
-#include <deal.II/base/std_cxx11/bind.h>
#include <deal.II/grid/tria.h>
#include <deal.II/grid/tria_accessor.h>
#include <deal.II/grid/tria_iterator.h>
void
TimeDependent::solve_primal_problem ()
{
- do_loop (std_cxx11::bind(&TimeStepBase::init_for_primal_problem, std_cxx11::_1),
- std_cxx11::bind(&TimeStepBase::solve_primal_problem, std_cxx11::_1),
+ do_loop (std::bind(&TimeStepBase::init_for_primal_problem, std::placeholders::_1),
+ std::bind(&TimeStepBase::solve_primal_problem, std::placeholders::_1),
timestepping_data_primal,
forward);
}
void
TimeDependent::solve_dual_problem ()
{
- do_loop (std_cxx11::bind(&TimeStepBase::init_for_dual_problem, std_cxx11::_1),
- std_cxx11::bind(&TimeStepBase::solve_dual_problem, std_cxx11::_1),
+ do_loop (std::bind(&TimeStepBase::init_for_dual_problem, std::placeholders::_1),
+ std::bind(&TimeStepBase::solve_dual_problem, std::placeholders::_1),
timestepping_data_dual,
backward);
}
void
TimeDependent::postprocess ()
{
- do_loop (std_cxx11::bind(&TimeStepBase::init_for_postprocessing, std_cxx11::_1),
- std_cxx11::bind(&TimeStepBase::postprocess_timestep, std_cxx11::_1),
+ do_loop (std::bind(&TimeStepBase::init_for_postprocessing, std::placeholders::_1),
+ std::bind(&TimeStepBase::postprocess_timestep, std::placeholders::_1),
timestepping_data_postprocess,
forward);
}
void (TimeDependent::*p) (const unsigned int, const unsigned int)
= &TimeDependent::end_sweep;
parallel::apply_to_subranges (0U, timesteps.size(),
- std_cxx11::bind (p, this, std_cxx11::_1, std_cxx11::_2),
+ std::bind (p, this, std::placeholders::_1, std::placeholders::_2),
1);
}
const DoFHandler<deal_II_dimension,deal_II_dimension> &,
const ConstraintMatrix &,
const Quadrature<deal_II_dimension> &,
- const std_cxx11::function<VEC::value_type (const DoFHandler<deal_II_dimension, deal_II_dimension>::active_cell_iterator &, const unsigned int)>,
+ const std::function<VEC::value_type (const DoFHandler<deal_II_dimension, deal_II_dimension>::active_cell_iterator &, const unsigned int)>,
VEC &);
\}
template
void project<deal_II_dimension, VEC>(
- std_cxx11::shared_ptr<const MatrixFree<deal_II_dimension,VEC::value_type> > matrix_free,
+ std::shared_ptr<const MatrixFree<deal_II_dimension,VEC::value_type> > matrix_free,
const ConstraintMatrix &constraints,
- const std_cxx11::function< VectorizedArray<VEC::value_type> (const unsigned int, const unsigned int)>,
+ const std::function< VectorizedArray<VEC::value_type> (const unsigned int, const unsigned int)>,
VEC &);
template
void project<deal_II_dimension, VEC>(
- std_cxx11::shared_ptr<const MatrixFree<deal_II_dimension,VEC::value_type> > matrix_free,
+ std::shared_ptr<const MatrixFree<deal_II_dimension,VEC::value_type> > matrix_free,
const ConstraintMatrix &constraints,
const unsigned int,
- const std_cxx11::function< VectorizedArray<VEC::value_type> (const unsigned int, const unsigned int)>,
+ const std::function< VectorizedArray<VEC::value_type> (const unsigned int, const unsigned int)>,
VEC &);
\}
tolerance(tolerance)
{
Assert(spacedim == 3, ExcNotImplemented());
- Assert(std_cxx11::get<0>(count_elements(sh)) > 0,
+ Assert(std::get<0>(count_elements(sh)) > 0,
ExcMessage("NormalToMeshProjectionBoundary needs a shape containing faces to operate."));
}
{
for (unsigned int i=0; i<surrounding_points.size(); ++i)
{
- std
_cxx11::tuple<Point<3>, Tensor<1,3>, double, double>
+ std::tuple<Point<3>, Tensor<1,3>, double, double>
p_and_diff_forms =
closest_point_and_differential_forms(sh,
surrounding_points[i],
tolerance);
- average_normal += std_cxx11::get<1>(p_and_diff_forms);
+ average_normal += std::get<1>(p_and_diff_forms);
}
average_normal/=2.0;
}
template<>
- std_cxx11::tuple<double, double, double, double>
+ std::tuple<double, double, double, double>
NURBSPatchManifold<2, 3>::
get_uv_bounds() const
{
Standard_Real umin, umax, vmin, vmax;
BRepTools::UVBounds(face, umin, umax, vmin, vmax);
- return std_cxx11::make_tuple(umin, umax, vmin, vmax);
+ return std::make_tuple(umin, umax, vmin, vmax);
}
// Explicit instantiations
namespace OpenCASCADE
{
- std_cxx11::tuple<unsigned int, unsigned int, unsigned int>
+ std::tuple<unsigned int, unsigned int, unsigned int>
count_elements(const TopoDS_Shape &shape)
{
TopExp_Explorer exp;
for (exp.Init(shape, TopAbs_VERTEX);
exp.More(); exp.Next(), ++n_vertices)
{}
- return std_cxx11::tuple<unsigned int, unsigned int, unsigned int>(n_faces, n_edges, n_vertices);
+ return std::tuple<unsigned int, unsigned int, unsigned int>(n_faces, n_edges, n_vertices);
}
void extract_geometrical_shapes(const TopoDS_Shape &shape,
return out_shape;
}
- std
_cxx11::tuple<Point<3>, TopoDS_Shape, double, double>
+ std::tuple<Point<3>, TopoDS_Shape, double, double>
project_point_and_pull_back(const TopoDS_Shape &in_shape,
const Point<3> &origin,
const double tolerance)
}
Assert(counter > 0, ExcMessage("Could not find projection points."));
- return std
_cxx11::tuple<Point<3>, TopoDS_Shape, double, double>
+ return std::tuple<Point<3>, TopoDS_Shape, double, double>
(point(Pproj),out_shape, u, v);
}
const Point<3> &origin,
const double tolerance)
{
- std
_cxx11::tuple<Point<3>, TopoDS_Shape, double, double>
+ std::tuple<Point<3>, TopoDS_Shape, double, double>
ref = project_point_and_pull_back(in_shape, origin, tolerance);
- return std_cxx11::get<0>(ref);
+ return std::get<0>(ref);
}
- std
_cxx11::tuple<Point<3>, Tensor<1,3>, double, double>
+ std::tuple<Point<3>, Tensor<1,3>, double, double>
closest_point_and_differential_forms(const TopoDS_Shape &in_shape,
const Point<3> &origin,
const double tolerance)
{
- std
_cxx11::tuple<Point<3>, TopoDS_Shape, double, double>
+ std::tuple<Point<3>, TopoDS_Shape, double, double>
shape_and_params = project_point_and_pull_back(in_shape,
origin,
tolerance);
- TopoDS_Shape &out_shape = std_cxx11::get<1>(shape_and_params);
- double &u = std_cxx11::get<2>(shape_and_params);
- double &v = std_cxx11::get<3>(shape_and_params);
+ TopoDS_Shape &out_shape = std::get<1>(shape_and_params);
+ double &u = std::get<2>(shape_and_params);
+ double &v = std::get<3>(shape_and_params);
// just a check here: the number of faces in out_shape must be 1, otherwise
// something is wrong
- std_cxx11::tuple<unsigned int, unsigned int, unsigned int> numbers =
+ std::tuple<unsigned int, unsigned int, unsigned int> numbers =
count_elements(out_shape);
(void)numbers;
- Assert(std_cxx11::get<0>(numbers) > 0,
+ Assert(std::get<0>(numbers) > 0,
ExcMessage("Could not find normal: the shape containing the closest point has 0 faces."));
- Assert(std_cxx11::get<0>(numbers) < 2,
+ Assert(std::get<0>(numbers) < 2,
ExcMessage("Could not find normal: the shape containing the closest point has more than 1 face."));
return Point<3>();
}
- std
_cxx11::tuple<Point<3>, Tensor<1,3>, double, double>
+ std::tuple<Point<3>, Tensor<1,3>, double, double>
push_forward_and_differential_forms(const TopoDS_Face &face,
const double u,
const double v,
Max_Curvature *= -1;
}
- return std
_cxx11::tuple<Point<3>, Tensor<1,3>, double, double>(point(Value), normal, Min_Curvature, Max_Curvature);
+ return std::tuple<Point<3>, Tensor<1,3>, double, double>(point(Value), normal, Min_Curvature, Max_Curvature);
}
constraints);
constraints.close ();
- std_cxx11::shared_ptr<MatrixFree<dim,double> > mf_data(new MatrixFree<dim,double> ());
+ std::shared_ptr<MatrixFree<dim,double> > mf_data(new MatrixFree<dim,double> ());
{
const QGauss<1> quad (fe_degree+1);
typename MatrixFree<dim,double>::AdditionalData data;
DataOutBase::VtkFlags vtkflags;
DataOutBase::Deal_II_IntermediateFlags deal_II_intermediateflags;
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > vectors;
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> > vectors;
WRITE(dx);
if (dim==2)
names[3] = "x4";
names[4] = "i";
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > vectors;
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> > vectors;
DataOutBase::write_dx(patches, names, vectors, flags, out);
}
std::vector<std::string> names(1);
names[0] = "CutOff";
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > vectors;
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> > vectors;
DataOutBase::write_dx(patches, names, vectors, flags, out);
}
names[2] = "x3";
names[3] = "x4";
names[4] = "i";
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > vectors;
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> > vectors;
DataOutBase::write_eps(patches, names, vectors, flags, out);
}
std::vector<std::string> names(1);
names[0] = "CutOff";
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > vectors;
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> > vectors;
DataOutBase::write_eps(patches, names, vectors, flags, out);
}
names[2] = "x3";
names[3] = "x4";
names[4] = "i";
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > vectors;
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> > vectors;
DataOutBase::write_gmv(patches, names, vectors, flags, out);
}
names[2] = "x3";
names[3] = "x4";
names[4] = "i";
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > vectors;
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> > vectors;
DataOutBase::write_gnuplot(patches, names, vectors, flags, out);
}
names[2] = "x3";
names[3] = "x4";
names[4] = "i";
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > vectors;
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> > vectors;
DataOutBase::write_gnuplot(patches, names, vectors, flags, out);
}
names[2] = "x3";
names[3] = "x4";
names[4] = "i";
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > vectors;
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> > vectors;
DataOutBase::write_povray(patches, names, vectors, flags, out);
}
std::vector<std::string> names(1);
names[0] = "CutOff";
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > vectors;
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> > vectors;
DataOutBase::write_povray(patches, names, vectors, flags, out);
}
names[2] = "x3";
names[3] = "x4";
names[4] = "i";
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > vectors;
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> > vectors;
DataOutBase::write_tecplot(patches, names, vectors, flags, out);
}
names[2] = "x3";
names[3] = "x4";
names[4] = "i";
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > vectors;
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> > vectors;
DataOutBase::write_tecplot_binary(patches, names, vectors, flags, out);
}
names[2] = "x3";
names[3] = "x4";
names[4] = "i";
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > vectors;
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> > vectors;
DataOutBase::write_vtk(patches, names, vectors, flags, out);
}
names[2] = "x3";
names[3] = "x4";
names[4] = "i";
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > vectors;
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> > vectors;
DataOutBase::write_vtk(patches, names, vectors, flags, out);
}
names[2] = "x3";
names[3] = "x4";
names[4] = "i";
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > vectors;
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> > vectors;
DataOutBase::write_vtk(patches, names, vectors, flags, out);
}
names[2] = "x3";
names[3] = "x4";
names[4] = "i";
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > vectors;
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> > vectors;
DataOutBase::write_vtk(patches, names, vectors, flags, out);
}
names[2] = "x3";
names[3] = "x4";
names[4] = "i";
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > vectors;
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> > vectors;
DataOutBase::write_vtu(patches, names, vectors, flags, out);
}
names[2] = "x3";
names[3] = "x4";
names[4] = "i";
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > vectors;
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> > vectors;
DataOutBase::write_vtu(patches, names, vectors, flags, out);
}
names[2] = "x3";
names[3] = "x4";
names[4] = "i";
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > vectors;
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> > vectors;
DataOutBase::write_vtu(patches, names, vectors, flags, out);
}
names[2] = "x3";
names[3] = "x4";
names[4] = "i";
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > vectors;
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> > vectors;
DataOutBase::write_vtu(patches, names, vectors, flags, out);
}
names[2] = "x3";
names[3] = "x4";
names[4] = "i";
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > vectors;
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> > vectors;
DataOutBase::write_vtu(patches, names, vectors, flags, out);
}
names[2] = "x3";
names[3] = "x4";
names[4] = "i";
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > vectors;
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> > vectors;
std::ostringstream old_data;
DataOutBase::write_deal_II_intermediate(patches, names, vectors,
WorkStream::run(v.begin(),
v.end(),
&assemble,
- std_cxx11::bind(©,
- std_cxx11::ref(result),
- std_cxx11::_1),
+ std::bind(©,
+ std::ref(result),
+ std::placeholders::_1),
scratch_data(), copy_data());
std::cout << "result: " << result << std::endl;
DataOutBase::DXFlags dxflags;
DataOutBase::GnuplotFlags gflags;
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > vectors;
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> > vectors;
if (dim==2)
DataOutBase::write_gnuplot(patches, names, vectors, gflags, out);
else
q[d] = d;
ScalarFunctionFromFunctionObject<dim>
- object (std_cxx11::bind (&Point<dim>::distance,
- q,
- std_cxx11::_1));
+ object (std::bind (&Point<dim>::distance,
+ q,
+ std::placeholders::_1));
for (unsigned int i=0; i<10; ++i)
{
q[d] = d;
ScalarFunctionFromFunctionObject<dim>
- object (std_cxx11::bind (&Point<dim>::distance,
- q,
- std_cxx11::_1));
+ object (std::bind (&Point<dim>::distance,
+ q,
+ std::placeholders::_1));
for (unsigned int i=0; i<10; ++i)
{
// now interpolate the function x*y*z onto points. note that this function is
// (bi/tri)linear and so we can later know what the correct value is that the
// function should provide
-Table<1,double> fill (const std_cxx11::array<std::vector<double>,1> &coordinates)
+Table<1,double> fill (const std::array<std::vector<double>,1> &coordinates)
{
Table<1,double> data(coordinates[0].size());
for (unsigned int i=0; i<coordinates[0].size(); ++i)
return data;
}
-Table<2,double> fill (const std_cxx11::array<std::vector<double>,2> &coordinates)
+Table<2,double> fill (const std::array<std::vector<double>,2> &coordinates)
{
Table<2,double> data(coordinates[0].size(),
coordinates[1].size());
return data;
}
-Table<3,double> fill (const std_cxx11::array<std::vector<double>,3> &coordinates)
+Table<3,double> fill (const std::array<std::vector<double>,3> &coordinates)
{
Table<3,double> data(coordinates[0].size(),
coordinates[1].size(),
{
// have coordinate arrays that span an interval starting at d+1
// d+5 nonuniform intervals
- std_cxx11::array<std::vector<double>,dim> coordinates;
+ std::array<std::vector<double>,dim> coordinates;
for (unsigned int d=0; d<dim; ++d)
for (unsigned int i=0; i<d+5; ++i)
coordinates[d].push_back (d+1 + 1.*i*i);
// now interpolate the function x*y*z onto points. note that this function is
// (bi/tri)linear and so we can later know what the correct value is that the
// function should provide
-Table<1,double> fill (const std_cxx11::array<std::vector<double>,1> &coordinates)
+Table<1,double> fill (const std::array<std::vector<double>,1> &coordinates)
{
Table<1,double> data(coordinates[0].size());
for (unsigned int i=0; i<coordinates[0].size(); ++i)
return data;
}
-Table<2,double> fill (const std_cxx11::array<std::vector<double>,2> &coordinates)
+Table<2,double> fill (const std::array<std::vector<double>,2> &coordinates)
{
Table<2,double> data(coordinates[0].size(),
coordinates[1].size());
return data;
}
-Table<3,double> fill (const std_cxx11::array<std::vector<double>,3> &coordinates)
+Table<3,double> fill (const std::array<std::vector<double>,3> &coordinates)
{
Table<3,double> data(coordinates[0].size(),
coordinates[1].size(),
{
// have coordinate arrays that span an interval starting at d+1
// d+5 nonuniform intervals
- std_cxx11::array<std::pair<double,double>,dim> intervals;
- std_cxx11::array<unsigned int,dim> n_subintervals;
+ std::array<std::pair<double,double>,dim> intervals;
+ std::array<unsigned int,dim> n_subintervals;
for (unsigned int d=0; d<dim; ++d)
{
intervals[d] = std::make_pair(d+2., 2*d+5.);
n_subintervals[d] = d+1 + d*d;
}
- std_cxx11::array<std::vector<double>,dim> coordinates;
+ std::array<std::vector<double>,dim> coordinates;
for (unsigned int d=0; d<dim; ++d)
{
const double x = intervals[d].first;
#include "../tests.h"
#include <deal.II/base/function.h>
#include <deal.II/lac/vector.h>
-#include <deal.II/base/std_cxx11/array.h>
+#include <array>
#include <vector>
#define MAX_DIM 3
DataOutBase::DXFlags dxflags;
DataOutBase::GnuplotFlags gflags;
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > vectors;
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> > vectors;
if (dim==2)
DataOutBase::write_gnuplot(patches, names, vectors, gflags, out);
else
{}
private:
- virtual double svalue(const std_cxx11::array<double, dim> &sp,
+ virtual double svalue(const std::array<double, dim> &sp,
const unsigned int) const
{
return std::exp(-Z*sp[0]);
}
- virtual std_cxx11::array<double, dim> sgradient(const std_cxx11::array<double, dim> &sp,
- const unsigned int) const
+ virtual std::array<double, dim> sgradient(const std::array<double, dim> &sp,
+ const unsigned int) const
{
- std_cxx11::array<double, dim> res;
+ std::array<double, dim> res;
res[0] = -Z*std::exp(-Z*sp[0]);
for (unsigned int i=1; i < dim; i++)
res[i] = 0.;
return res;
}
- virtual std_cxx11::array<double, 6> shessian (const std_cxx11::array<double, dim> &sp,
- const unsigned int) const
+ virtual std::array<double, 6> shessian (const std::array<double, dim> &sp,
+ const unsigned int) const
{
- std_cxx11::array<double, 6> res;
+ std::array<double, 6> res;
res[0] = Z*Z*std::exp(-Z*sp[0]);
for (unsigned int i=1; i < 6; i++)
res[i] = 0.;
for (double theta = 0; theta < 2*numbers::PI; theta+= numbers::PI/3.)
for (double phi = 0.01; phi <= numbers::PI; phi+= numbers::PI/4.)
{
- std_cxx11::array<double, dim> sp;
+ std::array<double, dim> sp;
sp[0] = r;
sp[1] = theta;
sp[2] = phi;
{}
private:
- virtual double svalue(const std_cxx11::array<double, dim> &sp,
+ virtual double svalue(const std::array<double, dim> &sp,
const unsigned int) const
{
return sp[0]*sp[0]*std::cos(sp[1])*std::sin(sp[2]);
}
- virtual std_cxx11::array<double, dim> sgradient(const std_cxx11::array<double, dim> &sp,
- const unsigned int) const
+ virtual std::array<double, dim> sgradient(const std::array<double, dim> &sp,
+ const unsigned int) const
{
- std_cxx11::array<double, dim> res;
+ std::array<double, dim> res;
const double r = sp[0];
const double theta = sp[1];
const double phi = sp[2];
return res;
}
- virtual std_cxx11::array<double, 6> shessian (const std_cxx11::array<double, dim> &sp,
- const unsigned int) const
+ virtual std::array<double, 6> shessian (const std::array<double, dim> &sp,
+ const unsigned int) const
{
- std_cxx11::array<double, 6> res;
+ std::array<double, 6> res;
const double r = sp[0];
const double theta = sp[1];
const double phi = sp[2];
for (double theta = 0; theta < 2*numbers::PI; theta+= numbers::PI/3.)
for (double phi = 0.01; phi <= numbers::PI; phi+= numbers::PI/4.)
{
- std_cxx11::array<double, dim> sp;
+ std::array<double, dim> sp;
sp[0] = r;
sp[1] = theta;
sp[2] = phi;
const Point<dim> origin;
- std_cxx1x::array<double,dim> sorigin;
+ std::array<double,dim> sorigin;
for (unsigned int d= 0; d < dim; d++)
sorigin[d] = 0.;
for (unsigned int d=0; d< dim; d++)
one[d] = 1.;
- std_cxx1x::array<double,dim> sone;
+ std::array<double,dim> sone;
sone[0] = std::sqrt(1.*dim);
sone[1] = numbers::PI/4;
if (dim==3)
const dealii::Point<3> y(0,1,0);
const dealii::Point<3> z(0,0,1);
- std_cxx1x::array<double,3> sx;
+ std::array<double,3> sx;
sx[0] = 1.;
sx[1] = 0;
sx[2] = numbers::PI/2;
- std_cxx1x::array<double,3> sy;
+ std::array<double,3> sy;
sy[0] = 1;
sy[1] = numbers::PI/2;
sy[2] = numbers::PI/2;
- std_cxx1x::array<double,3> sz;
+ std::array<double,3> sz;
sz[0] = 1.;
sz[1] = 0.;
sz[2] = 0.;
print<3>(to_spherical(z),sz);
const Point<3> dateline(0,-1,0);
- std_cxx1x::array<double,3> sdateline;
+ std::array<double,3> sdateline;
sdateline[0] = 1.;
sdateline[1] = 3*numbers::PI/2;
sdateline[2] = numbers::PI/2;
// have one-to-one correspondence
for (double phi = 0.01; phi <= numbers::PI; phi+= numbers::PI/4.)
{
- std_cxx11::array<double, dim> sp;
+ std::array<double, dim> sp;
sp[0] = r;
sp[1] = theta;
sp[2] = phi;
Point<dim> p = GeometricUtilities::Coordinates::from_spherical(sp);
- const std_cxx11::array<double, dim> sp2 = GeometricUtilities::Coordinates::to_spherical(p);
+ const std::array<double, dim> sp2 = GeometricUtilities::Coordinates::to_spherical(p);
for (unsigned int i = 0; i <dim; i++)
AssertThrow (std::fabs(sp[i]-sp2[i]) <= std::fabs(sp[i])*1e-10,
DifferentComponent(i,sp[i],sp2[i]));
typename DoFHandler<dim>::active_cell_iterator cell(dof_handler.begin_active());
std::vector<std::vector<typename DoFHandler<dim>::active_cell_iterator> > coloring(
GraphColoring::make_graph_coloring(cell,dof_handler.end(),
- std_cxx11::function<std::vector<types::global_dof_index> (typename
+ std::function<std::vector<types::global_dof_index> (typename
DoFHandler<dim>::active_cell_iterator const &)> (&get_conflict_indices_cfem<dim>)));
// Output the coloring
// Create the coloring
std::vector<std::vector<typename DoFHandler<dim>::active_cell_iterator> > coloring(
GraphColoring::make_graph_coloring(dof_handler.begin_active(),dof_handler.end(),
- std_cxx11::function<std::vector<types::global_dof_index> (typename
+ std::function<std::vector<types::global_dof_index> (typename
DoFHandler<dim>::active_cell_iterator const &)> (&get_conflict_indices_cfem<dim>)));
// Output the coloring
// Create the coloring
std::vector<std::vector<typename DoFHandler<dim>::active_cell_iterator> > coloring(
GraphColoring::make_graph_coloring(dof_handler.begin_active(),dof_handler.end(),
- std_cxx11::function<std::vector<types::global_dof_index> (typename
+ std::function<std::vector<types::global_dof_index> (typename
DoFHandler<dim>::active_cell_iterator const &)> (&get_conflict_indices_cfem<dim>)));
// verify that within each color, there is no conflict
// Create the coloring
std::vector<std::vector<typename hp::DoFHandler<dim>::active_cell_iterator> > coloring(
GraphColoring::make_graph_coloring(dof_handler.begin_active(),dof_handler.end(),
- std_cxx11::function<std::vector<types::global_dof_index> (typename
+ std::function<std::vector<types::global_dof_index> (typename
hp::DoFHandler<dim>::active_cell_iterator const &)> (&get_conflict_indices_cfem<dim>)));
// Output the coloring
std::vector<std::vector<typename DoFHandler<dim>::active_cell_iterator> > coloring
= GraphColoring::make_graph_coloring(stokes_dof_handler.begin_active(),
stokes_dof_handler.end(),
- std_cxx11::function<std::vector<types::global_dof_index> (
+ std::function<std::vector<types::global_dof_index> (
const typename DoFHandler<dim>::active_cell_iterator &)>(&get_conflict_indices<dim>));
for (unsigned int c=0; c<coloring.size(); ++c)
// Create the coloring
std::vector<std::vector<typename DoFHandler<dim>::active_cell_iterator> > coloring(
GraphColoring::make_graph_coloring(dof_handler.begin_active(),dof_handler.end(),
- std_cxx11::function<std::vector<types::global_dof_index> (typename
+ std::function<std::vector<types::global_dof_index> (typename
DoFHandler<dim>::active_cell_iterator const &)> (&get_conflict_indices_cfem<dim>)));
// Check that a color does not contain a conflict index twice
coloring
= GraphColoring::make_graph_coloring(dof_handler.begin_active(),
dof_handler.end(),
- std_cxx11::function<std::vector<types::global_dof_index>
+ std::function<std::vector<types::global_dof_index>
(typename DoFHandler<dim>::active_cell_iterator const &)>
(&get_conflict_indices_cfem<dim>));
-// test memory_consumption() on std_cxx11::array
+// test memory_consumption() on std::array
#include "../tests.h"
std::ofstream logfile("output");
deallog.attach(logfile);
- typedef std_cxx11::array<std_cxx11::array<int, 3>, 3> IntArray;
+ typedef std::array<std::array<int, 3>, 3> IntArray;
deallog << dealii::MemoryConsumption::memory_consumption(IntArray()) << std::endl;
deallog << sizeof(IntArray) << std::endl;
}
}
void test(TimeStepping::RungeKutta<Vector<double> > &solver,
- std_cxx11::function<Vector<double> (double const, Vector<double> const &)> f,
- std_cxx11::function<Vector<double> (double const, double const, Vector<double> const &)> id_minus_tau_J_inv,
- std_cxx11::function<double (double const)> my)
+ std::function<Vector<double> (double const, Vector<double> const &)> f,
+ std::function<Vector<double> (double const, double const, Vector<double> const &)> id_minus_tau_J_inv,
+ std::function<double (double const)> my)
{
unsigned int n_time_steps = 1;
unsigned int size = 1;
}
void test2(TimeStepping::EmbeddedExplicitRungeKutta<Vector<double> > &solver,
- std_cxx11::function<Vector<double> (double const, Vector<double> const &)> f,
- std_cxx11::function<Vector<double> (double const, double const, Vector<double> const &)> id_minus_tau_J_inv,
- std_cxx11::function<double (double const)> my)
+ std::function<Vector<double> (double const, Vector<double> const &)> f,
+ std::function<Vector<double> (double const, double const, Vector<double> const &)> id_minus_tau_J_inv,
+ std::function<double (double const)> my)
{
double initial_time = 0.0, final_time = 1.0;
double time_step = 1.0;
}
void test(TimeStepping::EmbeddedExplicitRungeKutta<Vector<double> > &solver,
- std_cxx11::function<Vector<double> (double const, Vector<double> const &)> f,
- std_cxx11::function<double (double const)> my)
+ std::function<Vector<double> (double const, Vector<double> const &)> f,
+ std::function<double (double const)> my)
{
double initial_time = 0.0, final_time = 1.0;
double time_step = 0.1;
#include "../tests.h"
-#include <deal.II/base/std_cxx11/unique_ptr.h>
+#include <memory>
#include <fstream>
#include <iomanip>
{
AssertThrow (counter == 0, ExcInternalError());
{
- std_cxx11::unique_ptr<X> p (new X);
+ std::unique_ptr<X> p (new X);
AssertThrow (counter == 1, ExcInternalError());
}
AssertThrow (counter == 0, ExcInternalError());
{
AssertThrow (counter == 0, ExcInternalError());
{
- std_cxx11::unique_ptr<X> p (new X);
+ std::unique_ptr<X> p (new X);
AssertThrow (counter == 1, ExcInternalError());
- std_cxx11::unique_ptr<X> q = std::move(p);
+ std::unique_ptr<X> q = std::move(p);
AssertThrow (counter == 1, ExcInternalError());
}
AssertThrow (counter == 0, ExcInternalError());
// this appears to be the key: the following two ways both overwrite some
// of the memory in which we store the quadrature point location.
parallel::apply_to_subranges(0U, copy_data.cell_rhs.size(),
- std_cxx11::bind(&zero_subrange, std_cxx11::_1, std_cxx11::_2,
- std_cxx11::ref(copy_data.cell_rhs)), 1);
+ std::bind(&zero_subrange, std::placeholders::_1, std::placeholders::_2,
+ std::ref(copy_data.cell_rhs)), 1);
AssertThrow(q == data.x_fe_values.quadrature_point(0),
ExcInternalError());
copy_data.cell_rhs.resize(8);
WorkStream::run(triangulation.begin_active(), triangulation.end(),
&mass_assembler<dim>,
- std_cxx11::bind(©_local_to_global, std_cxx11::_1, &sum),
+ std::bind(©_local_to_global, std::placeholders::_1, &sum),
assembler_data, copy_data, 8, 1);
Assert (std::fabs(sum-288.) < 1e-12, ExcInternalError());
// this appears to be the key: the following two ways both overwrite some
// of the memory in which we store the quadrature point location.
parallel::apply_to_subranges(0U, copy_data.cell_rhs.size(),
- std_cxx11::bind(&zero_subrange, std_cxx11::_1, std_cxx11::_2,
- std_cxx11::ref(copy_data.cell_rhs)), 1);
+ std::bind(&zero_subrange, std::placeholders::_1, std::placeholders::_2,
+ std::ref(copy_data.cell_rhs)), 1);
AssertThrow(q == data.x_fe_values.quadrature_point(0),
ExcInternalError());
copy_data.cell_rhs.resize(8);
WorkStream::run(GraphColoring::make_graph_coloring (triangulation.begin_active(),
triangulation.end(),
- std_cxx11::function<std::vector<types::global_dof_index>
+ std::function<std::vector<types::global_dof_index>
(const Triangulation<dim>::active_cell_iterator &)>
(&conflictor<dim>)),
&mass_assembler<dim>,
- std_cxx11::bind(©_local_to_global, std_cxx11::_1, &sum),
+ std::bind(©_local_to_global, std::placeholders::_1, &sum),
assembler_data, copy_data, 8, 1);
Assert (std::fabs(sum-288.) < 1e-12, ExcInternalError());
// first run with only a worker
WorkStream::run (v.begin(), v.end(),
&foo,
- std_cxx11::function<void(const unsigned int &)>(),
+ std::function<void(const unsigned int &)>(),
ScratchData(),
0U);
// next run with only a copier
WorkStream::run (v.begin(), v.end(),
- std_cxx11::function<void(const std::vector<unsigned int>::iterator,
- ScratchData &,unsigned int &)>(),
+ std::function<void(const std::vector<unsigned int>::iterator,
+ ScratchData &,unsigned int &)>(),
&bar,
ScratchData(),
0U);
v.push_back (i);
WorkStream::run (GraphColoring::make_graph_coloring (v.begin(), v.end(),
- std_cxx11::function<std::vector<types::global_dof_index>
+ std::function<std::vector<types::global_dof_index>
(const std::vector<unsigned int>::iterator &)>
(&conflictor)),
&worker, &copier,
if (!fe2.constraints_are_implemented())
return;
- std_cxx11::unique_ptr<Triangulation<dim> > tria(make_tria<dim>());
- std_cxx11::unique_ptr<DoFHandler<dim> > dof1(make_dof_handler (*tria, fe1));
- std_cxx11::unique_ptr<DoFHandler<dim> > dof2(make_dof_handler (*tria, fe2));
+ std::unique_ptr<Triangulation<dim> > tria(make_tria<dim>());
+ std::unique_ptr<DoFHandler<dim> > dof1(make_dof_handler (*tria, fe1));
+ std::unique_ptr<DoFHandler<dim> > dof2(make_dof_handler (*tria, fe2));
ConstraintMatrix cm;
DoFTools::make_hanging_node_constraints (*dof2, cm);
cm.close ();
!fe2.constraints_are_implemented())
return;
- std_cxx11::unique_ptr<Triangulation<dim> > tria(make_tria<dim>());
- std_cxx11::unique_ptr<DoFHandler<dim> > dof1(make_dof_handler (*tria, fe1));
- std_cxx11::unique_ptr<DoFHandler<dim> > dof2(make_dof_handler (*tria, fe2));
+ std::unique_ptr<Triangulation<dim> > tria(make_tria<dim>());
+ std::unique_ptr<DoFHandler<dim> > dof1(make_dof_handler (*tria, fe1));
+ std::unique_ptr<DoFHandler<dim> > dof2(make_dof_handler (*tria, fe2));
ConstraintMatrix cm1, cm2;
DoFTools::make_hanging_node_constraints (*dof1, cm1);
DoFTools::make_hanging_node_constraints (*dof2, cm2);
!fe2.constraints_are_implemented())
return;
- std_cxx11::unique_ptr<Triangulation<dim> > tria(make_tria<dim>());
- std_cxx11::unique_ptr<DoFHandler<dim> > dof1(make_dof_handler (*tria, fe1));
- std_cxx11::unique_ptr<DoFHandler<dim> > dof2(make_dof_handler (*tria, fe2));
+ std::unique_ptr<Triangulation<dim> > tria(make_tria<dim>());
+ std::unique_ptr<DoFHandler<dim> > dof1(make_dof_handler (*tria, fe1));
+ std::unique_ptr<DoFHandler<dim> > dof2(make_dof_handler (*tria, fe2));
ConstraintMatrix cm1, cm2;
DoFTools::make_hanging_node_constraints (*dof1, cm1);
DoFTools::make_hanging_node_constraints (*dof2, cm2);
GridGenerator::hyper_cube(tria, 0., 1.);
tria.refine_global (2);
- std_cxx11::unique_ptr<DoFHandler<dim> > dof1(make_dof_handler (tria, fe1));
+ std::unique_ptr<DoFHandler<dim> > dof1(make_dof_handler (tria, fe1));
Vector<double> in (dof1->n_dofs());
for (unsigned int i=0; i<in.size(); ++i)
tria.refine_global (2);
hp::FECollection<dim> hp_fe1(fe1);
- std_cxx11::unique_ptr<hp::DoFHandler<dim> > hp_dof1(make_hp_dof_handler (tria, hp_fe1));
+ std::unique_ptr<hp::DoFHandler<dim> > hp_dof1(make_hp_dof_handler (tria, hp_fe1));
Vector<double> in (hp_dof1->n_dofs());
for (unsigned int i=0; i<in.size(); ++i)
!fe2.constraints_are_implemented())
return;
- std_cxx11::unique_ptr<Triangulation<dim> > tria(make_tria<dim>());
- std_cxx11::unique_ptr<DoFHandler<dim> > dof1(make_dof_handler (*tria, fe1));
- std_cxx11::unique_ptr<DoFHandler<dim> > dof2(make_dof_handler (*tria, fe2));
+ std::unique_ptr<Triangulation<dim> > tria(make_tria<dim>());
+ std::unique_ptr<DoFHandler<dim> > dof1(make_dof_handler (*tria, fe1));
+ std::unique_ptr<DoFHandler<dim> > dof2(make_dof_handler (*tria, fe2));
ConstraintMatrix cm1, cm2;
DoFTools::make_hanging_node_constraints (*dof1, cm1);
DoFTools::make_hanging_node_constraints (*dof2, cm2);
if (!fe2.isotropic_restriction_is_implemented())
return;
- std_cxx11::unique_ptr<Triangulation<dim> > tria(make_tria<dim>());
- std_cxx11::unique_ptr<DoFHandler<dim> > dof1(make_dof_handler (*tria, fe1));
- std_cxx11::unique_ptr<DoFHandler<dim> > dof2(make_dof_handler (*tria, fe2));
+ std::unique_ptr<Triangulation<dim> > tria(make_tria<dim>());
+ std::unique_ptr<DoFHandler<dim> > dof1(make_dof_handler (*tria, fe1));
+ std::unique_ptr<DoFHandler<dim> > dof2(make_dof_handler (*tria, fe2));
ConstraintMatrix cm;
DoFTools::make_hanging_node_constraints (*dof2, cm);
cm.close ();
#include "../tests.h"
#include <deal.II/base/logstream.h>
-#include <deal.II/base/std_cxx11/unique_ptr.h>
#include <deal.II/grid/tria.h>
#include <deal.II/grid/tria_iterator.h>
#include <deal.II/grid/grid_generator.h>
#include <fstream>
#include <iomanip>
#include <iomanip>
+#include <memory>
#include <string>
WorkStream::run(dof_handler_u_post.begin_active(),
dof_handler_u_post.end(),
- std_cxx11::bind (&HDG<dim>::postprocess_one_cell,
- std_cxx11::ref(*this),
- std_cxx11::_1, std_cxx11::_2, std_cxx11::_3),
- std_cxx11::function<void(const unsigned int &)>(),
+ std::bind (&HDG<dim>::postprocess_one_cell,
+ std::ref(*this),
+ std::placeholders::_1, std::placeholders::_2, std::placeholders::_3),
+ std::function<void(const unsigned int &)>(),
scratch,
0U);
}
WorkStream::run(dof_handler_u_post.begin_active(),
dof_handler_u_post.end(),
- std_cxx11::bind (&HDG<dim>::postprocess_one_cell,
- std_cxx11::ref(*this),
- std_cxx11::_1, std_cxx11::_2, std_cxx11::_3),
- std_cxx11::function<void(const unsigned int &)>(),
+ std::bind (&HDG<dim>::postprocess_one_cell,
+ std::ref(*this),
+ std::placeholders::_1, std::placeholders::_2, std::placeholders::_3),
+ std::function<void(const unsigned int &)>(),
scratch,
0U);
}
{
const FiniteElement<dim> &fe = dof.get_fe();
std::vector<types::global_dof_index> v (fe.dofs_per_cell);
- std_cxx11::shared_ptr<FEValues<dim> > fevalues;
+ std::shared_ptr<FEValues<dim> > fevalues;
if (fe.has_support_points())
{
Quadrature<dim> quad(fe.get_unit_support_points());
- fevalues = std_cxx11::shared_ptr<FEValues<dim> >(new FEValues<dim>(fe, quad, update_quadrature_points));
+ fevalues = std::shared_ptr<FEValues<dim> >(new FEValues<dim>(fe, quad, update_quadrature_points));
}
for (typename DoFHandler<dim>::active_cell_iterator cell=dof.begin_active();
{
const FiniteElement<dim> &fe = dof.get_fe();
std::vector<types::global_dof_index> v (fe.dofs_per_cell);
- std_cxx11::shared_ptr<FEValues<dim> > fevalues;
+ std::shared_ptr<FEValues<dim> > fevalues;
if (fe.has_support_points())
{
Quadrature<dim> quad(fe.get_unit_support_points());
- fevalues = std_cxx11::shared_ptr<FEValues<dim> >(new FEValues<dim>(fe, quad, update_quadrature_points));
+ fevalues = std::shared_ptr<FEValues<dim> >(new FEValues<dim>(fe, quad, update_quadrature_points));
}
for (typename DoFHandler<dim>::cell_iterator cell=dof.begin(level);
{
const FiniteElement<dim> &fe = dof.get_fe();
std::vector<types::global_dof_index> v (fe.dofs_per_cell);
- std_cxx11::shared_ptr<FEValues<dim> > fevalues;
+ std::shared_ptr<FEValues<dim> > fevalues;
if (fe.has_support_points())
{
Quadrature<dim> quad(fe.get_unit_support_points());
- fevalues = std_cxx11::shared_ptr<FEValues<dim> >(new FEValues<dim>(fe, quad, update_quadrature_points));
+ fevalues = std::shared_ptr<FEValues<dim> >(new FEValues<dim>(fe, quad, update_quadrature_points));
}
for (typename DoFHandler<dim>::active_cell_iterator cell=dof.begin_active();
{
const FiniteElement<dim> &fe = dof.get_fe();
std::vector<types::global_dof_index> v (fe.dofs_per_cell);
- std_cxx11::shared_ptr<FEValues<dim> > fevalues;
+ std::shared_ptr<FEValues<dim> > fevalues;
if (fe.has_support_points())
{
Quadrature<dim> quad(fe.get_unit_support_points());
- fevalues = std_cxx11::shared_ptr<FEValues<dim> >(new FEValues<dim>(fe, quad, update_quadrature_points));
+ fevalues = std::shared_ptr<FEValues<dim> >(new FEValues<dim>(fe, quad, update_quadrature_points));
}
for (typename DoFHandler<dim>::active_cell_iterator cell=dof.begin_active();
{
const FiniteElement<dim> &fe = dof.get_fe();
std::vector<types::global_dof_index> v (fe.dofs_per_cell);
- std_cxx11::shared_ptr<FEValues<dim> > fevalues;
+ std::shared_ptr<FEValues<dim> > fevalues;
if (fe.has_support_points())
{
Quadrature<dim> quad(fe.get_unit_support_points());
- fevalues = std_cxx11::shared_ptr<FEValues<dim> >(new FEValues<dim>(fe, quad, update_quadrature_points));
+ fevalues = std::shared_ptr<FEValues<dim> >(new FEValues<dim>(fe, quad, update_quadrature_points));
}
for (typename DoFHandler<dim>::active_cell_iterator cell=dof.begin_active();
{
const FiniteElement<dim> &fe = dof.get_fe();
std::vector<types::global_dof_index> v (fe.dofs_per_cell);
- std_cxx11::shared_ptr<FEValues<dim> > fevalues;
+ std::shared_ptr<FEValues<dim> > fevalues;
if (fe.has_support_points())
{
Quadrature<dim> quad(fe.get_unit_support_points());
- fevalues = std_cxx11::shared_ptr<FEValues<dim> >(new FEValues<dim>(fe, quad, update_quadrature_points));
+ fevalues = std::shared_ptr<FEValues<dim> >(new FEValues<dim>(fe, quad, update_quadrature_points));
}
for (typename DoFHandler<dim>::active_cell_iterator cell=dof.begin_active();
{
const FiniteElement<dim> &fe = dof.get_fe();
std::vector<types::global_dof_index> v (fe.dofs_per_cell);
- std_cxx11::shared_ptr<FEValues<dim> > fevalues;
+ std::shared_ptr<FEValues<dim> > fevalues;
if (fe.has_support_points())
{
Quadrature<dim> quad(fe.get_unit_support_points());
- fevalues = std_cxx11::shared_ptr<FEValues<dim> >(new FEValues<dim>(fe, quad, update_quadrature_points));
+ fevalues = std::shared_ptr<FEValues<dim> >(new FEValues<dim>(fe, quad, update_quadrature_points));
}
for (typename DoFHandler<dim>::active_cell_iterator cell=dof.begin_active();
{
const FiniteElement<dim> &fe = dof.get_fe();
std::vector<types::global_dof_index> v (fe.dofs_per_cell);
- std_cxx11::shared_ptr<FEValues<dim> > fevalues;
+ std::shared_ptr<FEValues<dim> > fevalues;
if (fe.has_support_points())
{
Quadrature<dim> quad(fe.get_unit_support_points());
- fevalues = std_cxx11::shared_ptr<FEValues<dim> >(new FEValues<dim>(fe, quad, update_quadrature_points));
+ fevalues = std::shared_ptr<FEValues<dim> >(new FEValues<dim>(fe, quad, update_quadrature_points));
}
for (typename DoFHandler<dim>::active_cell_iterator cell=dof.begin_active();
{
const FiniteElement<dim> &fe = dof.get_fe();
std::vector<types::global_dof_index> v (fe.dofs_per_cell);
- std_cxx11::shared_ptr<FEValues<dim> > fevalues;
+ std::shared_ptr<FEValues<dim> > fevalues;
if (fe.has_support_points())
{
Quadrature<dim> quad(fe.get_unit_support_points());
- fevalues = std_cxx11::shared_ptr<FEValues<dim> >(new FEValues<dim>(fe, quad, update_quadrature_points));
+ fevalues = std::shared_ptr<FEValues<dim> >(new FEValues<dim>(fe, quad, update_quadrature_points));
}
for (typename DoFHandler<dim>::active_cell_iterator cell=dof.begin_active();
out << std::fixed;
const FiniteElement<dim> &fe = dof.get_fe();
std::vector<types::global_dof_index> v (fe.dofs_per_cell);
- std_cxx11::shared_ptr<FEValues<dim> > fevalues;
+ std::shared_ptr<FEValues<dim> > fevalues;
if (fe.has_support_points())
{
Quadrature<dim> quad(fe.get_unit_support_points());
- fevalues = std_cxx11::shared_ptr<FEValues<dim> >(new FEValues<dim>(fe, quad, update_quadrature_points));
+ fevalues = std::shared_ptr<FEValues<dim> >(new FEValues<dim>(fe, quad, update_quadrature_points));
}
for (typename DoFHandler<dim>::active_cell_iterator cell=dof.begin_active();
BlockVector<double> solution;
BlockVector<double> system_rhs;
- std_cxx11::shared_ptr<typename InnerPreconditioner<dim>::type>
+ std::shared_ptr<typename InnerPreconditioner<dim>::type>
A_preconditioner;
ConvergenceTable convergence_table;
}
A_preconditioner
- = std_cxx11::shared_ptr<typename InnerPreconditioner<dim>::type>(new
+ = std::shared_ptr<typename InnerPreconditioner<dim>::type>(new
typename InnerPreconditioner<dim>::type());
A_preconditioner->initialize (system_matrix.block(0,0),
typename
#include <deal.II/base/mpi.h>
#include <deal.II/base/multithread_info.h>
#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
#include <deal.II/base/utilities.h>
#include <deal.II/dofs/dof_tools.h>
#include <cmath>
#include <fstream>
#include <iostream>
+#include <memory>
#include <string>
#include <vector>
};
template <int dim>
-std_cxx11::shared_ptr<Manifold<dim> >
+std::shared_ptr<Manifold<dim> >
cubic_roof(Triangulation<dim> &triangulation)
{
- std_cxx11::shared_ptr<Manifold<dim> > boundary(new CubicRoofManifold<dim>());
+ std::shared_ptr<Manifold<dim> > boundary(new CubicRoofManifold<dim>());
GridGenerator::hyper_cube(triangulation);
triangulation.set_all_manifold_ids(cubic_manifold_id);
double run();
protected:
- std_cxx11::shared_ptr<Function<dim> > manufactured_solution;
- std_cxx11::shared_ptr<Function<dim> > manufactured_forcing;
+ std::shared_ptr<Function<dim> > manufactured_solution;
+ std::shared_ptr<Function<dim> > manufactured_forcing;
- std_cxx11::shared_ptr<Manifold<dim> > boundary_manifold;
+ std::shared_ptr<Manifold<dim> > boundary_manifold;
Triangulation<dim> triangulation;
FE_Q<dim> finite_element;
DoFHandler<dim> dof_handler;
bool (*predicate) (const active_cell_iterator, const unsigned int)
= &level_equal_to<active_cell_iterator>;
FilteredIterator<active_cell_iterator>
- begin (std_cxx11::bind (predicate, std_cxx11::_1, 3),
+ begin (std::bind (predicate, std::placeholders::_1, 3),
tria.begin_active (3)),
- end (std_cxx11::bind (predicate, std_cxx11::_1, 3),
+ end (std::bind (predicate, std::placeholders::_1, 3),
tria.end());
Assert (std::distance (begin, end) ==
bool (*predicate) (const active_cell_iterator, const unsigned int)
= &level_equal_to<active_cell_iterator>;
- Assert (std::distance (FI(std_cxx11::bind (predicate, std_cxx11::_1, 3))
+ Assert (std::distance (FI(std::bind (predicate, std::placeholders::_1, 3))
.set_to_next_positive(tria.begin_active()),
- FI(std_cxx11::bind (predicate, std_cxx11::_1, 3), tria.end())) ==
+ FI(std::bind (predicate, std::placeholders::_1, 3), tria.end())) ==
static_cast<signed int>(tria.n_active_cells (3)),
ExcInternalError());
logfile << "Check 4: "
- << (std::distance (FI(std_cxx11::bind (predicate, std_cxx11::_1, 3))
+ << (std::distance (FI(std::bind (predicate, std::placeholders::_1, 3))
.set_to_next_positive(tria.begin_active()),
- FI(std_cxx11::bind (predicate, std_cxx11::_1, 3), tria.end())) ==
+ FI(std::bind (predicate, std::placeholders::_1, 3), tria.end())) ==
static_cast<signed int>(tria.n_active_cells (3))
?
"OK" : "Failed")
bool (*predicate) (const active_cell_iterator, const unsigned int)
= &level_equal_to<active_cell_iterator>;
FilteredIterator<active_cell_iterator>
- begin (std_cxx11::bind (predicate, std_cxx11::_1, 3),
+ begin (std::bind (predicate, std::placeholders::_1, 3),
tria.begin_active (3)),
- end (std_cxx11::bind(predicate, std_cxx11::_1, 3),
+ end (std::bind(predicate, std::placeholders::_1, 3),
tria.end());
Assert (std::distance (begin, end) ==
bool (*predicate) (const active_cell_iterator, const unsigned int)
= &level_equal_to<active_cell_iterator>;
- Assert (std::distance (FI(std_cxx11::bind (predicate, std_cxx11::_1, 3))
+ Assert (std::distance (FI(std::bind (predicate, std::placeholders::_1, 3))
.set_to_next_positive(tria.begin_active()),
- FI(std_cxx11::bind (predicate, std_cxx11::_1, 3), tria.end())) ==
+ FI(std::bind (predicate, std::placeholders::_1, 3), tria.end())) ==
static_cast<signed int>(tria.n_active_cells (3)),
ExcInternalError());
logfile << "Check 4: "
- << (std::distance (FI(std_cxx11::bind (predicate, std_cxx11::_1, 3))
+ << (std::distance (FI(std::bind (predicate, std::placeholders::_1, 3))
.set_to_next_positive(tria.begin_active()),
- FI(std_cxx11::bind (predicate, std_cxx11::_1, 3), tria.end())) ==
+ FI(std::bind (predicate, std::placeholders::_1, 3), tria.end())) ==
static_cast<signed int>(tria.n_active_cells (3))
?
"OK" : "Failed")
for (unsigned int d=0; d<spacedim; ++d)
origin[d] = 0.1+d*1.0;
- std_cxx11::array<Tensor<1,spacedim>,dim> edges;
+ std::array<Tensor<1,spacedim>,dim> edges;
switch (dim)
{
case 1:
GridOut().write_vtk (tria, f);
}
- std_cxx11::function<bool (const cell_iterator &)> predicate = pred_mat_id<dim>;
+ std::function<bool (const cell_iterator &)> predicate = pred_mat_id<dim>;
// Compute a halo layer around material id 2 and set it to material id 3
const std::vector<cell_iterator> active_halo_layer
}
// Compute a halo layer around material id 2 and set it to material id 3
- std_cxx11::function<bool (const cell_iterator &)> predicate
+ std::function<bool (const cell_iterator &)> predicate
= IteratorFilters::MaterialIdEqualTo(2, true);
const std::vector<cell_iterator> active_halo_layer
= GridTools::compute_active_cell_halo_layer(tria, predicate);
std::set<types::material_id> material_ids;
material_ids.insert(2);
material_ids.insert(3);
- std_cxx11::function<bool (const cell_iterator &)> predicate
+ std::function<bool (const cell_iterator &)> predicate
= IteratorFilters::MaterialIdEqualTo(material_ids, true);
const std::vector<cell_iterator> active_halo_layer
= GridTools::compute_active_cell_halo_layer(tria, predicate);
}
// Compute a halo layer around active fe index 2 and set it to active fe index 3
- std_cxx11::function<bool (const cell_iterator &)> predicate
+ std::function<bool (const cell_iterator &)> predicate
= IteratorFilters::ActiveFEIndexEqualTo(2, true);
std::vector<cell_iterator> active_halo_layer
= GridTools::compute_active_cell_halo_layer(dof_handler, predicate);
std::set<unsigned int> index_set;
index_set.insert(2);
index_set.insert(3);
- std_cxx11::function<bool (const cell_iterator &)> predicate
+ std::function<bool (const cell_iterator &)> predicate
= IteratorFilters::ActiveFEIndexEqualTo(index_set, true);
std::vector<cell_iterator> active_halo_layer
= GridTools::compute_active_cell_halo_layer(dof_handler, predicate);
boost::signals2::connection connections_1[4]
= {tria_1.signals.pre_refinement
- .connect (std_cxx11::bind (&pre_refinement_notification<dim,dim>,
- "tria_1",
- std_cxx11::cref(tria_1))),
+ .connect (std::bind (&pre_refinement_notification<dim,dim>,
+ "tria_1",
+ std::cref(tria_1))),
tria_1.signals.post_refinement
- .connect (std_cxx11::bind (&post_refinement_notification<dim,dim>,
- "tria_1",
- std_cxx11::cref(tria_1))),
+ .connect (std::bind (&post_refinement_notification<dim,dim>,
+ "tria_1",
+ std::cref(tria_1))),
tria_1.signals.create
- .connect (std_cxx11::bind (&create_notification<dim,dim>,
- "tria_1",
- std_cxx11::cref(tria_1))),
+ .connect (std::bind (&create_notification<dim,dim>,
+ "tria_1",
+ std::cref(tria_1))),
tria_1.signals.copy
- .connect (std_cxx11::bind (©_notification<dim,dim>,
- "tria_1",
- std_cxx11::_1,
- std_cxx11::cref(tria_1)))
+ .connect (std::bind (©_notification<dim,dim>,
+ "tria_1",
+ std::placeholders::_1,
+ std::cref(tria_1)))
};
boost::signals2::connection connections_2[4]
= {tria_2.signals.pre_refinement
- .connect (std_cxx11::bind (&pre_refinement_notification<dim,dim>,
- "tria_2",
- std_cxx11::cref(tria_2))),
+ .connect (std::bind (&pre_refinement_notification<dim,dim>,
+ "tria_2",
+ std::cref(tria_2))),
tria_2.signals.post_refinement
- .connect (std_cxx11::bind (&post_refinement_notification<dim,dim>,
- "tria_2",
- std_cxx11::cref(tria_2))),
+ .connect (std::bind (&post_refinement_notification<dim,dim>,
+ "tria_2",
+ std::cref(tria_2))),
tria_2.signals.create
- .connect (std_cxx11::bind (&create_notification<dim,dim>,
- "tria_2",
- std_cxx11::cref(tria_2))),
+ .connect (std::bind (&create_notification<dim,dim>,
+ "tria_2",
+ std::cref(tria_2))),
tria_2.signals.copy
- .connect (std_cxx11::bind (©_notification<dim,dim>,
- "tria_2",
- std_cxx11::_1,
- std_cxx11::cref(tria_2)))
+ .connect (std::bind (©_notification<dim,dim>,
+ "tria_2",
+ std::placeholders::_1,
+ std::cref(tria_2)))
};
boost::signals2::connection connections_1[5]
= {tria_1.signals.pre_refinement
- .connect (std_cxx11::bind (&pre_refinement_notification<dim,dim>,
- "tria_1",
- std_cxx11::cref(tria_1))),
+ .connect (std::bind (&pre_refinement_notification<dim,dim>,
+ "tria_1",
+ std::cref(tria_1))),
tria_1.signals.post_refinement
- .connect (std_cxx11::bind (&post_refinement_notification<dim,dim>,
- "tria_1",
- std_cxx11::cref(tria_1))),
+ .connect (std::bind (&post_refinement_notification<dim,dim>,
+ "tria_1",
+ std::cref(tria_1))),
tria_1.signals.create
- .connect (std_cxx11::bind (&create_notification<dim,dim>,
- "tria_1",
- std_cxx11::cref(tria_1))),
+ .connect (std::bind (&create_notification<dim,dim>,
+ "tria_1",
+ std::cref(tria_1))),
tria_1.signals.copy
- .connect (std_cxx11::bind (©_notification<dim,dim>,
- "tria_1",
- std_cxx11::_1,
- std_cxx11::cref(tria_1))),
+ .connect (std::bind (©_notification<dim,dim>,
+ "tria_1",
+ std::placeholders::_1,
+ std::cref(tria_1))),
tria_1.signals.any_change
- .connect (std_cxx11::bind (&any_change_notification<dim,dim>,
- "tria_1",
- std_cxx11::cref(tria_1)))
+ .connect (std::bind (&any_change_notification<dim,dim>,
+ "tria_1",
+ std::cref(tria_1)))
};
boost::signals2::connection connections_2[5]
= {tria_2.signals.pre_refinement
- .connect (std_cxx11::bind (&pre_refinement_notification<dim,dim>,
- "tria_2",
- std_cxx11::cref(tria_2))),
+ .connect (std::bind (&pre_refinement_notification<dim,dim>,
+ "tria_2",
+ std::cref(tria_2))),
tria_2.signals.post_refinement
- .connect (std_cxx11::bind (&post_refinement_notification<dim,dim>,
- "tria_2",
- std_cxx11::cref(tria_2))),
+ .connect (std::bind (&post_refinement_notification<dim,dim>,
+ "tria_2",
+ std::cref(tria_2))),
tria_2.signals.create
- .connect (std_cxx11::bind (&create_notification<dim,dim>,
- "tria_2",
- std_cxx11::cref(tria_2))),
+ .connect (std::bind (&create_notification<dim,dim>,
+ "tria_2",
+ std::cref(tria_2))),
tria_2.signals.copy
- .connect (std_cxx11::bind (©_notification<dim,dim>,
- "tria_2",
- std_cxx11::_1,
- std_cxx11::cref(tria_2))),
+ .connect (std::bind (©_notification<dim,dim>,
+ "tria_2",
+ std::placeholders::_1,
+ std::cref(tria_2))),
tria_2.signals.any_change
- .connect (std_cxx11::bind (&any_change_notification<dim,dim>,
- "tria_2",
- std_cxx11::cref(tria_2)))
+ .connect (std::bind (&any_change_notification<dim,dim>,
+ "tria_2",
+ std::cref(tria_2)))
};
const int spacedim = 2;
Triangulation<dim, spacedim> tria;
Point<spacedim> origin;
- std_cxx11::array<Tensor<1,spacedim>,dim> edges;
+ std::array<Tensor<1,spacedim>,dim> edges;
edges[0] = Point<spacedim>(2.0, 0.0)-Point<spacedim>();
edges[1] = Point<spacedim>(0.2, 0.8)-Point<spacedim>();
GridGenerator::subdivided_parallelepiped<dim, spacedim> (tria,
{
Triangulation<dim, spacedim> tria;
Point<spacedim> origin(0.1, 0.2, 0.3);
- std_cxx11::array<Tensor<1,spacedim>,dim> edges;
+ std::array<Tensor<1,spacedim>,dim> edges;
edges[0] = Point<spacedim>(2.0, 0.0, 0.1)-Point<spacedim>();
if (dim>=2)
edges[1] = Point<spacedim>(0.2, 0.8, 0.15)-Point<spacedim>();
#include <deal.II/grid/grid_out.h>
#include <deal.II/base/exceptions.h>
#include <deal.II/base/point.h>
-#include <deal.II/base/std_cxx11/array.h>
#include <deal.II/base/tensor.h>
+#include <array>
#include <fstream>
/*
{
// Data structure defining dim coordinates that make up a
// parallelepiped.
- std_cxx11::array<Tensor<1, dim>, dim> edges;
+ std::array<Tensor<1, dim>, dim> edges;
switch (dim)
{
#include <deal.II/grid/grid_out.h>
#include <deal.II/base/exceptions.h>
#include <deal.II/base/point.h>
-#include <deal.II/base/std_cxx11/array.h>
#include <deal.II/base/tensor.h>
+#include <array>
#include <fstream>
/*
{
// Data structure defining dim coordinates that make up a
// parallelepiped.
- std_cxx11::array<Tensor<1, dim>, dim> edges;
+ std::array<Tensor<1, dim>, dim> edges;
switch (dim)
{
#include <deal.II/lac/full_matrix.h>
#include <deal.II/lac/householder.h>
-#include <deal.II/base/std_cxx11/array.h>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
+#include <array>
+#include <memory>
#include <iostream>
* grid: see step-6.
*/
template <int dim>
-std_cxx11::shared_ptr<dealii::Manifold<dim> >
+std::shared_ptr<dealii::Manifold<dim> >
ladutenko_circle(dealii::Triangulation<dim> &triangulation,
const dealii::Point<dim> center = dealii::Point<dim>(),
const double radius = 1.0);
template <int dim>
-std_cxx11::shared_ptr<Manifold<dim > >
+std::shared_ptr<Manifold<dim > >
ladutenko_circle(Triangulation<dim> &triangulation,
const Point<dim> center,
const double radius)
{
- std_cxx11::shared_ptr<Manifold<dim> > boundary(new SphericalManifold<dim>(center));
+ std::shared_ptr<Manifold<dim> > boundary(new SphericalManifold<dim>(center));
GridGenerator::hyper_ball (triangulation, center, radius);
triangulation.set_all_manifold_ids(circular_manifold_id);
triangulation.set_manifold (circular_manifold_id, *boundary);
const unsigned int n_global_refines;
- std_cxx11::shared_ptr<Manifold<dim> > boundary_manifold;
+ std::shared_ptr<Manifold<dim> > boundary_manifold;
Triangulation<dim> triangulation;
hp::FECollection<dim> finite_elements;
hp::DoFHandler<dim> dof_handler;
hp::QCollection<dim-1> face_quadrature_collection;
hp::QCollection<dim> fourier_q_collection;
- std_cxx11::shared_ptr<FESeries::Fourier<dim> > fourier;
+ std::shared_ptr<FESeries::Fourier<dim> > fourier;
std::vector<double> ln_k;
Table<dim,std::complex<double> > fourier_coefficients;
for (unsigned int i = 0; i < fe_collection.size(); i++)
fourier_q_collection.push_back(quadrature);
- fourier = std_cxx11::make_shared<FESeries::Fourier<dim> >(N,
- fe_collection,
- fourier_q_collection);
+ fourier = std::make_shared<FESeries::Fourier<dim> >(N,
+ fe_collection,
+ fourier_q_collection);
resize(fourier_coefficients,N);
}
#include <deal.II/meshworker/assembler.h>
#include <deal.II/meshworker/loop.h>
-#include <deal.II/base/std_cxx11/function.h>
#include <deal.II/base/logstream.h>
#include <deal.II/grid/grid_generator.h>
#include <deal.II/dofs/dof_tools.h>
#include <deal.II/lac/block_vector.h>
#include <fstream>
+#include <functional>
#include <iomanip>
using namespace dealii;
MeshWorker::loop<dim, dim, MeshWorker::DoFInfo<dim>, EmptyInfoBox>
(dofs.begin_active(), dofs.end(),
dof_info, info_box,
- std_cxx11::bind (&Local<dim>::cell, local, std_cxx11::_1, std_cxx11::_2),
- std_cxx11::bind (&Local<dim>::bdry, local, std_cxx11::_1, std_cxx11::_2),
- std_cxx11::bind (&Local<dim>::face, local, std_cxx11::_1, std_cxx11::_2, std_cxx11::_3, std_cxx11::_4),
+ std::bind (&Local<dim>::cell, local, std::placeholders::_1, std::placeholders::_2),
+ std::bind (&Local<dim>::bdry, local, std::placeholders::_1, std::placeholders::_2),
+ std::bind (&Local<dim>::face, local, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4),
assembler, lctrl);
deallog << " Results cells";
MeshWorker::loop<dim, dim, MeshWorker::DoFInfo<dim>, EmptyInfoBox>
(mgdofs.begin_mg(), mgdofs.end_mg(),
mg_dof_info, info_box,
- std_cxx11::bind (&Local<dim>::cell, local, std_cxx11::_1, std_cxx11::_2),
- std_cxx11::bind (&Local<dim>::bdry, local, std_cxx11::_1, std_cxx11::_2),
- std_cxx11::bind (&Local<dim>::face, local, std_cxx11::_1, std_cxx11::_2, std_cxx11::_3, std_cxx11::_4),
+ std::bind (&Local<dim>::cell, local, std::placeholders::_1, std::placeholders::_2),
+ std::bind (&Local<dim>::bdry, local, std::placeholders::_1, std::placeholders::_2),
+ std::bind (&Local<dim>::face, local, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4),
assembler, lctrl);
deallog << "MGResults cells";
#include <deal.II/meshworker/assembler.h>
#include <deal.II/meshworker/loop.h>
-#include <deal.II/base/std_cxx11/function.h>
#include <deal.II/base/logstream.h>
#include <deal.II/grid/grid_generator.h>
#include <deal.II/dofs/dof_tools.h>
#include <deal.II/fe/fe_dgp.h>
#include <fstream>
+#include <functional>
#include <iomanip>
using namespace dealii;
MeshWorker::loop<dim, dim, MeshWorker::DoFInfo<dim>, EmptyInfoBox>
(dofs.begin_active(), dofs.end(),
dof_info, info_box,
- std_cxx11::bind (&Local<dim>::cell, local, std_cxx11::_1, std_cxx11::_2),
- std_cxx11::bind (&Local<dim>::bdry, local, std_cxx11::_1, std_cxx11::_2),
- std_cxx11::bind (&Local<dim>::face, local, std_cxx11::_1, std_cxx11::_2, std_cxx11::_3, std_cxx11::_4),
+ std::bind (&Local<dim>::cell, local, std::placeholders::_1, std::placeholders::_2),
+ std::bind (&Local<dim>::bdry, local, std::placeholders::_1, std::placeholders::_2),
+ std::bind (&Local<dim>::face, local, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4),
assembler, lctrl);
deallog << " Results";
MeshWorker::loop<dim, dim, MeshWorker::DoFInfo<dim>, EmptyInfoBox>
(mgdofs.begin_mg(), mgdofs.end_mg(),
mg_dof_info, info_box,
- std_cxx11::bind (&Local<dim>::cell, local, std_cxx11::_1, std_cxx11::_2),
- std_cxx11::bind (&Local<dim>::bdry, local, std_cxx11::_1, std_cxx11::_2),
- std_cxx11::bind (&Local<dim>::face, local, std_cxx11::_1, std_cxx11::_2, std_cxx11::_3, std_cxx11::_4),
+ std::bind (&Local<dim>::cell, local, std::placeholders::_1, std::placeholders::_2),
+ std::bind (&Local<dim>::bdry, local, std::placeholders::_1, std::placeholders::_2),
+ std::bind (&Local<dim>::face, local, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4),
assembler, lctrl);
deallog << "MGResults";
#include <deal.II/meshworker/assembler.h>
#include <deal.II/meshworker/loop.h>
-#include <deal.II/base/std_cxx11/function.h>
#include <deal.II/base/logstream.h>
#include <deal.II/lac/sparsity_pattern.h>
#include <deal.II/lac/sparse_matrix.h>
#include <deal.II/fe/fe_dgp.h>
#include <fstream>
+#include <functional>
#include <iomanip>
using namespace dealii;
MeshWorker::loop<dim, dim, MeshWorker::DoFInfo<dim>, MeshWorker::IntegrationInfoBox<dim> >
(dofs.begin_active(), dofs.end(),
dof_info, info_box,
- std_cxx11::bind (&Local<dim>::cell, local, std_cxx11::_1, std_cxx11::_2),
- std_cxx11::bind (&Local<dim>::bdry, local, std_cxx11::_1, std_cxx11::_2),
- std_cxx11::bind (&Local<dim>::face, local, std_cxx11::_1, std_cxx11::_2, std_cxx11::_3, std_cxx11::_4),
+ std::bind (&Local<dim>::cell, local, std::placeholders::_1, std::placeholders::_2),
+ std::bind (&Local<dim>::bdry, local, std::placeholders::_1, std::placeholders::_2),
+ std::bind (&Local<dim>::face, local, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4),
assembler, lctrl);
for (unsigned int i=0; i<v.size(); ++i)
std::ofstream logfile(logname.c_str());
deallog.attach(logfile);
- std::vector<std_cxx11::shared_ptr<FiniteElement<2> > > fe2;
- fe2.push_back(std_cxx11::shared_ptr<FiniteElement<2> >(new FE_DGP<2>(1)));
- fe2.push_back(std_cxx11::shared_ptr<FiniteElement<2> >(new FE_Q<2>(1)));
+ std::vector<std::shared_ptr<FiniteElement<2> > > fe2;
+ fe2.push_back(std::shared_ptr<FiniteElement<2> >(new FE_DGP<2>(1)));
+ fe2.push_back(std::shared_ptr<FiniteElement<2> >(new FE_Q<2>(1)));
for (unsigned int i=0; i<fe2.size(); ++i)
test(*fe2[i]);
std::ofstream logfile(logname.c_str());
deallog.attach(logfile);
- std::vector<std_cxx11::shared_ptr<FiniteElement<2> > > fe2;
- fe2.push_back(std_cxx11::shared_ptr<FiniteElement<2> >(new FE_DGP<2>(1)));
-// fe2.push_back(std_cxx11::shared_ptr<FiniteElement<2> >(new FE_Q<2>(1)));
+ std::vector<std::shared_ptr<FiniteElement<2> > > fe2;
+ fe2.push_back(std::shared_ptr<FiniteElement<2> >(new FE_DGP<2>(1)));
+// fe2.push_back(std::shared_ptr<FiniteElement<2> >(new FE_Q<2>(1)));
for (unsigned int i=0; i<fe2.size(); ++i)
test(*fe2[i]);
FE_DGP<2> dgp1(1);
FE_Q<2> q1(1);
- std::vector<std_cxx11::shared_ptr<FiniteElement<2> > > fe2;
- fe2.push_back(std_cxx11::shared_ptr<FiniteElement<2> >(new FE_DGP<2>(0)));
- fe2.push_back(std_cxx11::shared_ptr<FiniteElement<2> >(new FESystem<2>(dgp0,3)));
- fe2.push_back(std_cxx11::shared_ptr<FiniteElement<2> >(new FESystem<2>(dgp1,2)));
- fe2.push_back(std_cxx11::shared_ptr<FiniteElement<2> >(new FESystem<2>(q1,2)));
- fe2.push_back(std_cxx11::shared_ptr<FiniteElement<2> >(new FESystem<2>(dgp0,1,q1,1)));
-// fe2.push_back(std_cxx11::shared_ptr<FiniteElement<2> >(new FE_Q<2>(1)));
+ std::vector<std::shared_ptr<FiniteElement<2> > > fe2;
+ fe2.push_back(std::shared_ptr<FiniteElement<2> >(new FE_DGP<2>(0)));
+ fe2.push_back(std::shared_ptr<FiniteElement<2> >(new FESystem<2>(dgp0,3)));
+ fe2.push_back(std::shared_ptr<FiniteElement<2> >(new FESystem<2>(dgp1,2)));
+ fe2.push_back(std::shared_ptr<FiniteElement<2> >(new FESystem<2>(q1,2)));
+ fe2.push_back(std::shared_ptr<FiniteElement<2> >(new FESystem<2>(dgp0,1,q1,1)));
+// fe2.push_back(std::shared_ptr<FiniteElement<2> >(new FE_Q<2>(1)));
for (unsigned int i=0; i<fe2.size(); ++i)
test(*fe2[i]);
#include <deal.II/meshworker/assembler.h>
#include <deal.II/meshworker/loop.h>
-#include <deal.II/base/std_cxx11/function.h>
#include <deal.II/base/logstream.h>
#include <deal.II/lac/sparsity_pattern.h>
#include <deal.II/lac/sparse_matrix.h>
#include <deal.II/numerics/data_out.h>
#include <fstream>
+#include <functional>
#include <iomanip>
using namespace dealii;
MeshWorker::loop<dim, dim, MeshWorker::DoFInfo<dim>, MeshWorker::IntegrationInfoBox<dim> >
(dof_handler.begin_active(), dof_handler.end(),
dof_info, info_box,
- std_cxx11::bind(&AdvectionProblem<dim>::integrate_cell_term,
- this, std_cxx11::_1, std_cxx11::_2),
- std_cxx11::bind(&AdvectionProblem<dim>::integrate_boundary_term,
- this, std_cxx11::_1, std_cxx11::_2),
- std_cxx11::bind(&AdvectionProblem<dim>::integrate_face_term,
- this, std_cxx11::_1, std_cxx11::_2, std_cxx11::_3, std_cxx11::_4),
+ std::bind(&AdvectionProblem<dim>::integrate_cell_term,
+ this, std::placeholders::_1, std::placeholders::_2),
+ std::bind(&AdvectionProblem<dim>::integrate_boundary_term,
+ this, std::placeholders::_1, std::placeholders::_2),
+ std::bind(&AdvectionProblem<dim>::integrate_face_term,
+ this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4),
assembler, lctrl);
}//assemble_system
#include <deal.II/meshworker/assembler.h>
#include <deal.II/meshworker/loop.h>
-#include <deal.II/base/std_cxx11/function.h>
#include <deal.II/base/logstream.h>
#include <deal.II/lac/sparsity_pattern.h>
#include <deal.II/lac/sparse_matrix.h>
#include <deal.II/fe/fe_system.h>
#include <fstream>
+#include <functional>
#include <iomanip>
using namespace dealii;
MeshWorker::loop<dim, dim, MeshWorker::DoFInfo<dim>, MeshWorker::IntegrationInfoBox<dim> >
(dofs.begin_active(), dofs.end(),
dof_info, info_box,
- std_cxx11::bind (&Local<dim>::cell, local, std_cxx11::_1, std_cxx11::_2),
- std_cxx11::bind (&Local<dim>::bdry, local, std_cxx11::_1, std_cxx11::_2),
- std_cxx11::bind (&Local<dim>::face, local, std_cxx11::_1, std_cxx11::_2, std_cxx11::_3, std_cxx11::_4),
+ std::bind (&Local<dim>::cell, local, std::placeholders::_1, std::placeholders::_2),
+ std::bind (&Local<dim>::bdry, local, std::placeholders::_1, std::placeholders::_2),
+ std::bind (&Local<dim>::face, local, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4),
assembler, lctrl);
//matrix.print_formatted(deallog.get_file_stream(), 0, false, 4);
#include "../tests.h"
#include <deal.II/base/logstream.h>
-#include <deal.II/base/std_cxx11/bind.h>
#include <deal.II/lac/block_vector.h>
#include <fstream>
#include <iomanip>
#include <numeric>
#include <utility>
#include <cmath>
+#include <functional>
template <typename number>
bool operator == (const BlockVector<number> &v1,
// check std::transform
std::transform (v1.begin(), v1.end(), v2.begin(),
- std_cxx11::bind (std::multiplies<double>(),
- std_cxx11::_1,
- 2.0));
+ std::bind (std::multiplies<double>(),
+ std::placeholders::_1,
+ 2.0));
v2 *= 1./2;
deallog << "Check 7: " << (v1 == v2 ? "true" : "false") << std::endl;
#include "../tests.h"
#include <deal.II/base/logstream.h>
-#include <deal.II/base/std_cxx11/bind.h>
#include <deal.II/lac/block_vector.h>
#include <fstream>
#include <iomanip>
#include <numeric>
#include <utility>
#include <cmath>
+#include <functional>
template <typename number>
bool operator == (const BlockVector<number> &v1,
// check std::transform
std::transform (v1.begin(), v1.end(), v2.begin(),
- std_cxx11::bind (std::multiplies<std::complex<double> >(),
- std_cxx11::_1,
- 2.0));
+ std::bind (std::multiplies<std::complex<double> >(),
+ std::placeholders::_1,
+ 2.0));
v2 *= std::complex<double>(1./2.);
deallog << "Check 7: " << (v1 == v2 ? "true" : "false") << std::endl;
std::string fluid_fe_name = "FESystem[FE_Nothing()^2-FE_Nothing()^2-FE_Q(2)^2-FE_Q(1)-FE_Q(2)^2]";
hp::FECollection<dim> fe_collection;
- std_cxx11::unique_ptr<FiniteElement<dim> > solid_fe (FETools::get_fe_by_name<dim, dim>(solid_fe_name));
- std_cxx11::unique_ptr<FiniteElement<dim> > fluid_fe (FETools::get_fe_by_name<dim, dim>(fluid_fe_name));
+ std::unique_ptr<FiniteElement<dim> > solid_fe (FETools::get_fe_by_name<dim, dim>(solid_fe_name));
+ std::unique_ptr<FiniteElement<dim> > fluid_fe (FETools::get_fe_by_name<dim, dim>(fluid_fe_name));
deallog << "Solid FE Space: " << solid_fe->get_name() << std::endl;
deallog << "Fluid/Mesh FE Space: " << fluid_fe->get_name() << std::endl;
//Attach all possible slots.
solver_cg.connect_coefficients_slot(&output_coefficients);
solver_cg.connect_condition_number_slot(
- std_cxx11::bind(output_double_number,std_cxx11::_1,"Condition number: "),true);
+ std::bind(output_double_number,std::placeholders::_1,"Condition number: "),true);
solver_cg.connect_condition_number_slot(
- std_cxx11::bind(output_double_number,std_cxx11::_1,"Final condition number: "));
+ std::bind(output_double_number,std::placeholders::_1,"Final condition number: "));
solver_cg.connect_eigenvalues_slot(
- std_cxx11::bind(output_eigenvalues<double>,std_cxx11::_1,"Eigenvalues: "),true);
+ std::bind(output_eigenvalues<double>,std::placeholders::_1,"Eigenvalues: "),true);
solver_cg.connect_eigenvalues_slot(
- std_cxx11::bind(output_eigenvalues<double>,std_cxx11::_1,"Final Eigenvalues: "));
+ std::bind(output_eigenvalues<double>,std::placeholders::_1,"Final Eigenvalues: "));
solver_cg.solve(A,u,f,PreconditionIdentity());
u=0;
SolverGMRES<> solver_gmres(solver_control);
//Attach all possible slots.
solver_gmres.connect_condition_number_slot(
- std_cxx11::bind(output_double_number,std_cxx11::_1,"Condition number: "),true);
+ std::bind(output_double_number,std::placeholders::_1,"Condition number: "),true);
solver_gmres.connect_condition_number_slot(
- std_cxx11::bind(output_double_number,std_cxx11::_1,"Final condition number: "));
+ std::bind(output_double_number,std::placeholders::_1,"Final condition number: "));
solver_gmres.connect_eigenvalues_slot(
- std_cxx11::bind(output_eigenvalues<std::complex<double> >,std_cxx11::_1,"Eigenvalues: "),true);
+ std::bind(output_eigenvalues<std::complex<double> >,std::placeholders::_1,"Eigenvalues: "),true);
solver_gmres.connect_eigenvalues_slot(
- std_cxx11::bind(output_eigenvalues<std::complex<double> >,std_cxx11::_1,"Final Eigenvalues: "));
+ std::bind(output_eigenvalues<std::complex<double> >,std::placeholders::_1,"Final Eigenvalues: "));
solver_gmres.connect_hessenberg_slot(
- std_cxx11::bind(output_hessenberg_matrix<double>,std_cxx11::_1,"Hessenberg matrix: "),false);
+ std::bind(output_hessenberg_matrix<double>,std::placeholders::_1,"Hessenberg matrix: "),false);
solver_gmres.connect_krylov_space_slot(
- std_cxx11::bind(output_arnoldi_vectors_norms<double>,std_cxx11::_1,"Arnoldi vectors norms: "));
+ std::bind(output_arnoldi_vectors_norms<double>,std::placeholders::_1,"Arnoldi vectors norms: "));
solver_gmres.solve(A,u,f,PreconditionIdentity());
}
catch (std::exception &e)
{
const unsigned int size = 17 + test*1101;
- std_cxx11::shared_ptr< ::dealii::parallel::internal::TBBPartitioner> thread_loop_partitioner;
+ std::shared_ptr< ::dealii::parallel::internal::TBBPartitioner> thread_loop_partitioner;
thread_loop_partitioner.reset(new ::dealii::parallel::internal::TBBPartitioner());
Number *val;
{
const unsigned int size = 17 + test*1101;
- std_cxx11::shared_ptr< ::dealii::parallel::internal::TBBPartitioner> thread_loop_partitioner;
+ std::shared_ptr< ::dealii::parallel::internal::TBBPartitioner> thread_loop_partitioner;
thread_loop_partitioner.reset(new ::dealii::parallel::internal::TBBPartitioner());
Number *val;
#include "../tests.h"
#include <deal.II/base/utilities.h>
-#include <deal.II/base/std_cxx11/shared_ptr.h>
#include <deal.II/grid/manifold_lib.h>
#include <deal.II/base/quadrature_lib.h>
#include <fstream>
#include <iostream>
+#include <memory>
#include <deal.II/grid/manifold.h>
// << " degrees of freedom."
// << std::endl;
- std_cxx11::shared_ptr<Mapping<2,3> > mapping;
+ std::shared_ptr<Mapping<2,3> > mapping;
switch (mapping_name)
{
case MappingEnum::MappingManifold:
void create_tria(Triangulation<dim> &triangulation, const Geometry<dim> &geometry)
{
GridGenerator::hyper_cube (triangulation, -1.0, 1.0);
- GridTools::transform (std_cxx11::bind(&Geometry<dim>::push_forward,
- std_cxx11::cref(geometry),
- std_cxx11::_1),
+ GridTools::transform (std::bind(&Geometry<dim>::push_forward,
+ std::cref(geometry),
+ std::placeholders::_1),
triangulation);
triangulation.set_manifold(0, geometry);
GridGenerator::hyper_cube (triangulation, -1., 1.);
triangulation.refine_global(3);
- GridTools::transform (std_cxx11::bind(&Geometry<dim>::push_forward,
- std_cxx11::cref(geometry),
- std_cxx11::_1),
+ GridTools::transform (std::bind(&Geometry<dim>::push_forward,
+ std::cref(geometry),
+ std::placeholders::_1),
triangulation);
triangulation.set_manifold(0, geometry);
Point<dim> direction;
direction[dim-1] = 1.;
- std_cxx11::shared_ptr<Manifold<dim> > cylinder_manifold
+ std::shared_ptr<Manifold<dim> > cylinder_manifold
(dim == 2 ? static_cast<Manifold<dim>*>(new SphericalManifold<dim>(Point<dim>())) :
static_cast<Manifold<dim>*>(new CylindricalManifold<dim>(direction, Point<dim>())));
Point<dim> direction;
direction[dim-1] = 1.;
- std_cxx11::shared_ptr<Manifold<dim> > cylinder_manifold
+ std::shared_ptr<Manifold<dim> > cylinder_manifold
(dim == 2 ? static_cast<Manifold<dim>*>(new SphericalManifold<dim>(center)) :
static_cast<Manifold<dim>*>(new CylindricalManifold<dim>(direction, center)));
Triangulation<dim> tria;
const Vector<Number> &src) const
{
dst = 0;
- const std_cxx11::function<void(const MatrixFree<dim,Number> &,
- Vector<Number> &,
- const Vector<Number> &,
- const std::pair<unsigned int,unsigned int> &)>
+ const std::function<void(const MatrixFree<dim,Number> &,
+ Vector<Number> &,
+ const Vector<Number> &,
+ const std::pair<unsigned int,unsigned int> &)>
wrap = mass_operator<dim,fe_degree,Number>;
data.cell_loop (wrap, dst, src);
};
//std::cout << "Number of degrees of freedom: " << dof.n_dofs() << std::endl;
//std::cout << "Number of constraints: " << constraints.n_constraints() << std::endl;
- std_cxx11::shared_ptr<MatrixFree<dim,number> > mf_data(new MatrixFree<dim,number> ());
+ std::shared_ptr<MatrixFree<dim,number> > mf_data(new MatrixFree<dim,number> ());
{
const QGauss<1> quad (fe_degree+1);
typename MatrixFree<dim,number>::AdditionalData data;
//std::cout << "Number of degrees of freedom: " << dof.n_dofs() << std::endl;
//std::cout << "Number of constraints: " << constraints.n_constraints() << std::endl;
- std_cxx11::shared_ptr<MatrixFree<dim,number> > mf_data(new MatrixFree<dim,number> ());
+ std::shared_ptr<MatrixFree<dim,number> > mf_data(new MatrixFree<dim,number> ());
{
const QGauss<1> quad (fe_degree+1);
typename MatrixFree<dim,number>::AdditionalData data;
mf_data->reinit (dof, constraints, quad, data);
}
- std
_cxx11::shared_ptr<Table<2, VectorizedArray<number> > > coefficient;
- coefficient = std
_cxx11::make_shared<Table<2, VectorizedArray<number> > >();
+ std::shared_ptr<Table<2, VectorizedArray<number> > > coefficient;
+ coefficient = std::make_shared<Table<2, VectorizedArray<number> > >();
{
FEEvaluation<dim,fe_degree,fe_degree+1,1,number> fe_eval(*mf_data);
//std::cout << "Number of degrees of freedom: " << dof.n_dofs() << std::endl;
//std::cout << "Number of constraints: " << constraints.n_constraints() << std::endl;
- std_cxx11::shared_ptr<MatrixFree<dim,number> > mf_data(new MatrixFree<dim,number> ());
+ std::shared_ptr<MatrixFree<dim,number> > mf_data(new MatrixFree<dim,number> ());
{
const QGauss<1> quad (fe_degree+2);
typename MatrixFree<dim,number>::AdditionalData data;
//std::cout << "Number of degrees of freedom: " << dof.n_dofs() << std::endl;
//std::cout << "Number of constraints: " << constraints.n_constraints() << std::endl;
- std_cxx11::shared_ptr<MatrixFree<dim,number> > mf_data(new MatrixFree<dim,number> ());
+ std::shared_ptr<MatrixFree<dim,number> > mf_data(new MatrixFree<dim,number> ());
{
const QGauss<1> quad (fe_degree+2);
typename MatrixFree<dim,number>::AdditionalData data;
//std::cout << "Number of degrees of freedom: " << dof.n_dofs() << std::endl;
//std::cout << "Number of constraints: " << constraints.n_constraints() << std::endl;
- std_cxx11::shared_ptr<MatrixFree<dim,number> > mf_data(new MatrixFree<dim,number> ());
+ std::shared_ptr<MatrixFree<dim,number> > mf_data(new MatrixFree<dim,number> ());
{
const QGauss<1> quad (fe_degree+2);
typename MatrixFree<dim,number>::AdditionalData data;
constraints_0.close();
constraints_1.close();
- std_cxx11::shared_ptr<MatrixFree<dim,number> > mf_data_0(new MatrixFree<dim,number> ());
- std_cxx11::shared_ptr<MatrixFree<dim,number> > mf_data_1(new MatrixFree<dim,number> ());
- std_cxx11::shared_ptr<MatrixFree<dim,number> > mf_data_combined(new MatrixFree<dim,number> ());
+ std::shared_ptr<MatrixFree<dim,number> > mf_data_0(new MatrixFree<dim,number> ());
+ std::shared_ptr<MatrixFree<dim,number> > mf_data_1(new MatrixFree<dim,number> ());
+ std::shared_ptr<MatrixFree<dim,number> > mf_data_combined(new MatrixFree<dim,number> ());
const QGauss<1> quad (2);
typename MatrixFree<dim,number>::AdditionalData data;
data.tasks_parallel_scheme =
{
for (unsigned int i=0; i<dst.size(); ++i)
dst[i] = 0;
- const std_cxx11::function<void(const MatrixFree<dim,Number> &,
- std::vector<LinearAlgebra::distributed::Vector<Number> > &,
- const std::vector<LinearAlgebra::distributed::Vector<Number> > &,
- const std::pair<unsigned int,unsigned int> &)>
+ const std::function<void(const MatrixFree<dim,Number> &,
+ std::vector<LinearAlgebra::distributed::Vector<Number> > &,
+ const std::vector<LinearAlgebra::distributed::Vector<Number> > &,
+ const std::pair<unsigned int,unsigned int> &)>
wrap = helmholtz_operator<dim,fe_degree,Number>;
data.cell_loop (wrap, dst, src);
};
const LinearAlgebra::distributed::BlockVector<Number> &src) const
{
dst = 0;
- const std_cxx11::function<void(const MatrixFree<dim,Number> &,
- LinearAlgebra::distributed::BlockVector<Number> &,
- const LinearAlgebra::distributed::BlockVector<Number> &,
- const std::pair<unsigned int,unsigned int> &)>
+ const std::function<void(const MatrixFree<dim,Number> &,
+ LinearAlgebra::distributed::BlockVector<Number> &,
+ const LinearAlgebra::distributed::BlockVector<Number> &,
+ const std::pair<unsigned int,unsigned int> &)>
wrap = helmholtz_operator<dim,fe_degree,Number>;
data.cell_loop (wrap, dst, src);
};
{
for (unsigned int i=0; i<dst.size(); ++i)
dst[i] = 0;
- const std_cxx11::function<void(const MatrixFree<dim,Number> &,
- parallel::distributed::BlockVector<Number> &,
- const parallel::distributed::BlockVector<Number> &,
- const std::pair<unsigned int,unsigned int> &)>
+ const std::function<void(const MatrixFree<dim,Number> &,
+ parallel::distributed::BlockVector<Number> &,
+ const parallel::distributed::BlockVector<Number> &,
+ const std::pair<unsigned int,unsigned int> &)>
wrap = helmholtz_operator<dim,fe_degree,Number>;
data.cell_loop (wrap, dst, src);
};
{
for (unsigned int i=0; i<dst.size(); ++i)
dst[i] = 0;
- const std_cxx11::function<void(const MatrixFree<dim,Number> &,
- parallel::distributed::BlockVector<Number> &,
- const parallel::distributed::BlockVector<Number> &,
- const std::pair<unsigned int,unsigned int> &)>
+ const std::function<void(const MatrixFree<dim,Number> &,
+ parallel::distributed::BlockVector<Number> &,
+ const parallel::distributed::BlockVector<Number> &,
+ const std::pair<unsigned int,unsigned int> &)>
wrap = helmholtz_operator<dim,fe_degree,Number>;
data.cell_loop (wrap, dst, src);
};
{
for (unsigned int i=0; i<dst.size(); ++i)
*dst[i] = 0;
- const std_cxx11::function<void(const MatrixFree<dim,Number> &,
- std::vector<LinearAlgebra::distributed::Vector<Number> *> &,
- const std::vector<LinearAlgebra::distributed::Vector<Number> *> &,
- const std::pair<unsigned int,unsigned int> &)>
+ const std::function<void(const MatrixFree<dim,Number> &,
+ std::vector<LinearAlgebra::distributed::Vector<Number> *> &,
+ const std::vector<LinearAlgebra::distributed::Vector<Number> *> &,
+ const std::pair<unsigned int,unsigned int> &)>
wrap = helmholtz_operator<dim,fe_degree,Number>;
data.cell_loop (wrap, dst, src);
};
{
for (unsigned int i=0; i<dst.size(); ++i)
*dst[i] = 0;
- const std_cxx11::function<void(const MatrixFree<dim,Number> &,
- std::vector<LinearAlgebra::distributed::Vector<Number> *> &,
- const std::vector<LinearAlgebra::distributed::Vector<Number> *> &,
- const std::pair<unsigned int,unsigned int> &)>
+ const std::function<void(const MatrixFree<dim,Number> &,
+ std::vector<LinearAlgebra::distributed::Vector<Number> *> &,
+ const std::vector<LinearAlgebra::distributed::Vector<Number> *> &,
+ const std::pair<unsigned int,unsigned int> &)>
wrap = helmholtz_operator<dim,fe_degree,Number>;
data.cell_loop (wrap, dst, src);
};
const VectorType &src) const
{
dst = 0;
- const std_cxx11::function<void(const MatrixFree<dim,typename VectorType::value_type> &,
- VectorType &,
- const VectorType &,
- const std::pair<unsigned int,unsigned int> &)>
+ const std::function<void(const MatrixFree<dim,typename VectorType::value_type> &,
+ VectorType &,
+ const VectorType &,
+ const std::pair<unsigned int,unsigned int> &)>
wrap = helmholtz_operator<dim,fe_degree,VectorType,n_q_points_1d>;
data.cell_loop (wrap, dst, src);
};
dof_u.distribute_dofs(fe_u);
dof_p.distribute_dofs(fe_p);
- std_cxx11::shared_ptr<MatrixFree<dim, double> > mf_data;
+ std::shared_ptr<MatrixFree<dim, double> > mf_data;
dof.distribute_dofs(fe);
ConstraintMatrix constraints, constraints_u, constraints_p;
mf_system_rhs.block(1)(j) = val;
}
- mf_data = std_cxx11::shared_ptr<MatrixFree<dim, double> >(new MatrixFree<dim, double>());
+ mf_data = std::shared_ptr<MatrixFree<dim, double> >(new MatrixFree<dim, double>());
// setup matrix-free structure
{
std::vector<const DoFHandler<dim>*> dofs;
MappingQ<dim> mapping(fe_degree+1);
LaplaceOperator<dim,fe_degree,n_q_points_1d,1,LinearAlgebra::distributed::Vector<number> > fine_matrix;
- std_cxx11::shared_ptr<MatrixFree<dim,number> > fine_level_data(new MatrixFree<dim,number> ());
+ std::shared_ptr<MatrixFree<dim,number> > fine_level_data(new MatrixFree<dim,number> ());
typename MatrixFree<dim,number>::AdditionalData fine_level_additional_data;
fine_level_additional_data.tasks_parallel_scheme = MatrixFree<dim,number>::AdditionalData::none;
mg_level_data[level].reinit (mapping, dof, level_constraints, QGauss<1>(n_q_points_1d),
mg_additional_data);
- mg_matrices[level].initialize(std_cxx11::make_shared<MatrixFree<dim,number> >(
+ mg_matrices[level].initialize(std::make_shared<MatrixFree<dim,number> >(
mg_level_data[level]),
mg_constrained_dofs,
level);
MappingQ<dim> mapping(fe_degree+1);
LaplaceOperator<dim,fe_degree,n_q_points_1d,1,LinearAlgebra::distributed::Vector<number> > fine_matrix;
- std_cxx11::shared_ptr<MatrixFree<dim,number> > fine_level_data(new MatrixFree<dim,number> ());
+ std::shared_ptr<MatrixFree<dim,number> > fine_level_data(new MatrixFree<dim,number> ());
typename MatrixFree<dim,number>::AdditionalData fine_level_additional_data;
fine_level_additional_data.tasks_parallel_scheme = MatrixFree<dim,number>::AdditionalData::none;
mg_level_data[level].reinit (mapping, dof, level_constraints, QGauss<1>(n_q_points_1d),
mg_additional_data);
- mg_matrices[level].initialize(std_cxx11::make_shared<MatrixFree<dim,number> >(
+ mg_matrices[level].initialize(std::make_shared<MatrixFree<dim,number> >(
mg_level_data[level]),
mg_constrained_dofs,
level);
MappingQ<dim> mapping(fe_degree+1);
LaplaceOperator<dim,fe_degree,n_q_points_1d,1,LinearAlgebra::distributed::Vector<number> > fine_matrix;
- std_cxx11::shared_ptr<MatrixFree<dim,number> > fine_level_data(new MatrixFree<dim,number> ());
+ std::shared_ptr<MatrixFree<dim,number> > fine_level_data(new MatrixFree<dim,number> ());
typename MatrixFree<dim,number>::AdditionalData fine_level_additional_data;
fine_level_additional_data.tasks_parallel_scheme = MatrixFree<dim,number>::AdditionalData::none;
mg_level_data[level].reinit (mapping, dof, level_constraints, QGauss<1>(n_q_points_1d),
mg_additional_data);
- mg_matrices[level].initialize(std_cxx11::make_shared<MatrixFree<dim,number> > (
+ mg_matrices[level].initialize(std::make_shared<MatrixFree<dim,number> > (
mg_level_data[level]),
mg_constrained_dofs,
level);
// repartition the mesh as described above, first in some arbitrary
// way, and then with all equal weights
- tr.signals.cell_weight.connect(std_cxx11::bind(&cell_weight_1<dim>,
- std_cxx11::_1,
- std_cxx11::_2));
+ tr.signals.cell_weight.connect(std::bind(&cell_weight_1<dim>,
+ std::placeholders::_1,
+ std::placeholders::_2));
tr.repartition();
tr.signals.cell_weight.disconnect_all_slots();
- tr.signals.cell_weight.connect(std_cxx11::bind(&cell_weight_2<dim>,
- std_cxx11::_1,
- std_cxx11::_2));
+ tr.signals.cell_weight.connect(std::bind(&cell_weight_2<dim>,
+ std::placeholders::_1,
+ std::placeholders::_2));
tr.repartition();
// repartition the mesh as described above, first in some arbitrary
// way, and then with no weights
- tr.signals.cell_weight.connect(std_cxx11::bind(&cell_weight_1<dim>,
- std_cxx11::_1,
- std_cxx11::_2));
+ tr.signals.cell_weight.connect(std::bind(&cell_weight_1<dim>,
+ std::placeholders::_1,
+ std::placeholders::_2));
tr.repartition();
tr.signals.cell_weight.disconnect_all_slots();
GridGenerator::subdivided_hyper_cube(tr, 16);
- tr.signals.cell_weight.connect(std_cxx11::bind(&cell_weight<dim>,
- std_cxx11::_1,
- std_cxx11::_2));
+ tr.signals.cell_weight.connect(std::bind(&cell_weight<dim>,
+ std::placeholders::_1,
+ std::placeholders::_2));
tr.refine_global(1);
if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
tr.refine_global(1);
- tr.signals.cell_weight.connect(std_cxx11::bind(&cell_weight<dim>,
- std_cxx11::_1,
- std_cxx11::_2));
+ tr.signals.cell_weight.connect(std::bind(&cell_weight<dim>,
+ std::placeholders::_1,
+ std::placeholders::_2));
tr.repartition();
GridGenerator::subdivided_hyper_cube(tr, 16);
- tr.signals.cell_weight.connect(std_cxx11::bind(&cell_weight<dim>,
- std_cxx11::_1,
- std_cxx11::_2));
+ tr.signals.cell_weight.connect(std::bind(&cell_weight<dim>,
+ std::placeholders::_1,
+ std::placeholders::_2));
tr.refine_global(1);
// repartition the mesh; attach different weights to all cells
- tr.signals.cell_weight.connect(std_cxx11::bind(&cell_weight<dim>,
- std_cxx11::_1,
- std_cxx11::_2));
+ tr.signals.cell_weight.connect(std::bind(&cell_weight<dim>,
+ std::placeholders::_1,
+ std::placeholders::_2));
tr.repartition ();
// repartition the mesh; attach different weights to all cells
n_global_active_cells = tr.n_global_active_cells();
- tr.signals.cell_weight.connect(std_cxx11::bind(&cell_weight<dim>,
- std_cxx11::_1,
- std_cxx11::_2));
+ tr.signals.cell_weight.connect(std::bind(&cell_weight<dim>,
+ std::placeholders::_1,
+ std::placeholders::_2));
tr.repartition ();
if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
template <int dim>
void testit()
{
- std::vector<std_cxx11::shared_ptr<FiniteElement<dim> > > fes;
- fes.push_back(std_cxx11::shared_ptr<FiniteElement<dim> >(new FE_RaviartThomas<dim>(0)));
- fes.push_back(std_cxx11::shared_ptr<FiniteElement<dim> >(new FE_RaviartThomas<dim>(1)));
- fes.push_back(std_cxx11::shared_ptr<FiniteElement<dim> >(new FE_Nedelec<dim>(0)));
- fes.push_back(std_cxx11::shared_ptr<FiniteElement<dim> >(new FE_Nedelec<dim>(1)));
- fes.push_back(std_cxx11::shared_ptr<FiniteElement<dim> >(new FE_Q<dim>(3)));
- fes.push_back(std_cxx11::shared_ptr<FiniteElement<dim> >(new FE_DGQ<dim>(2)));
- fes.push_back(std_cxx11::shared_ptr<FiniteElement<dim> >(new FE_Q_DG0<dim>(2)));
+ std::vector<std::shared_ptr<FiniteElement<dim> > > fes;
+ fes.push_back(std::shared_ptr<FiniteElement<dim> >(new FE_RaviartThomas<dim>(0)));
+ fes.push_back(std::shared_ptr<FiniteElement<dim> >(new FE_RaviartThomas<dim>(1)));
+ fes.push_back(std::shared_ptr<FiniteElement<dim> >(new FE_Nedelec<dim>(0)));
+ fes.push_back(std::shared_ptr<FiniteElement<dim> >(new FE_Nedelec<dim>(1)));
+ fes.push_back(std::shared_ptr<FiniteElement<dim> >(new FE_Q<dim>(3)));
+ fes.push_back(std::shared_ptr<FiniteElement<dim> >(new FE_DGQ<dim>(2)));
+ fes.push_back(std::shared_ptr<FiniteElement<dim> >(new FE_Q_DG0<dim>(2)));
for (unsigned int i=0; i<fes.size(); ++i)
{
#include "../tests.h"
#include <deal.II/base/logstream.h>
-#include <deal.II/base/std_cxx11/unique_ptr.h>
#include <deal.II/grid/tria.h>
#include <deal.II/grid/tria_iterator.h>
#include <deal.II/grid/grid_generator.h>
#include <fstream>
#include <iomanip>
-#include <iomanip>
+#include <memory>
#include <string>
//#define DEBUG_OUTPUT_VTK
if (!fe2.isotropic_restriction_is_implemented())
return;
- std
_cxx11::unique_ptr<parallel::distributed::Triangulation<dim> > tria(make_tria<dim>());
+ std::unique_ptr<parallel::distributed::Triangulation<dim> > tria(make_tria<dim>());
- std_cxx11::unique_ptr<DoFHandler<dim> > dof1(make_dof_handler (*tria, fe1));
- std_cxx11::unique_ptr<DoFHandler<dim> > dof2(make_dof_handler (*tria, fe2));
+ std::unique_ptr<DoFHandler<dim> > dof1(make_dof_handler (*tria, fe1));
+ std::unique_ptr<DoFHandler<dim> > dof2(make_dof_handler (*tria, fe2));
ConstraintMatrix cm1;
DoFTools::make_hanging_node_constraints (*dof1, cm1);
cm1.close ();
if (!fe2.isotropic_restriction_is_implemented())
return;
- std
_cxx11::unique_ptr<parallel::distributed::Triangulation<dim> > tria(make_tria<dim>());
+ std::unique_ptr<parallel::distributed::Triangulation<dim> > tria(make_tria<dim>());
- std_cxx11::unique_ptr<DoFHandler<dim> > dof1(make_dof_handler (*tria, fe1));
- std_cxx11::unique_ptr<DoFHandler<dim> > dof2(make_dof_handler (*tria, fe2));
+ std::unique_ptr<DoFHandler<dim> > dof1(make_dof_handler (*tria, fe1));
+ std::unique_ptr<DoFHandler<dim> > dof2(make_dof_handler (*tria, fe2));
ConstraintMatrix cm1;
DoFTools::make_hanging_node_constraints (*dof1, cm1);
cm1.close ();
// typename identity<ITERATOR>::type end,
// DOFINFO &dinfo,
// INFOBOX &info,
-// const std_cxx11::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &cell_worker,
-// const std_cxx11::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &boundary_worker,
-// const std_cxx11::function<void (DOFINFO &, DOFINFO &,
+// const std::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &cell_worker,
+// const std::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &boundary_worker,
+// const std::function<void (DOFINFO &, DOFINFO &,
// typename INFOBOX::CellInfo &,
// typename INFOBOX::CellInfo &)> &face_worker,
// ASSEMBLER &assembler,
// MeshWorker::loop<dim, dim, MeshWorker::DoFInfo<dim>, MeshWorker::IntegrationInfoBox<dim> >
// (dofs.begin_active(), dofs.end(),
// dof_info, info_box,
-// std_cxx11::bind (&Integrator<dim>::cell, local, std_cxx11::_1, std_cxx11::_2),
-// std_cxx11::bind (&Integrator<dim>::bdry, local, std_cxx11::_1, std_cxx11::_2),
-// std_cxx11::bind (&Integrator<dim>::face, local, std_cxx11::_1, std_cxx11::_2, std_cxx11::_3, std_cxx11::_4),
+// std::bind (&Integrator<dim>::cell, local, std::placeholders::_1, std::placeholders::_2),
+// std::bind (&Integrator<dim>::bdry, local, std::placeholders::_1, std::placeholders::_2),
+// std::bind (&Integrator<dim>::face, local, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4),
// local,
// lctrl);
}
// typename identity<ITERATOR>::type end,
// DOFINFO &dinfo,
// INFOBOX &info,
-// const std_cxx11::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &cell_worker,
-// const std_cxx11::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &boundary_worker,
-// const std_cxx11::function<void (DOFINFO &, DOFINFO &,
+// const std::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &cell_worker,
+// const std::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &boundary_worker,
+// const std::function<void (DOFINFO &, DOFINFO &,
// typename INFOBOX::CellInfo &,
// typename INFOBOX::CellInfo &)> &face_worker,
// ASSEMBLER &assembler,
// MeshWorker::loop<dim, dim, MeshWorker::DoFInfo<dim>, MeshWorker::IntegrationInfoBox<dim> >
// (dofs.begin_active(), dofs.end(),
// dof_info, info_box,
-// std_cxx11::bind (&Integrator<dim>::cell, local, std_cxx11::_1, std_cxx11::_2),
-// std_cxx11::bind (&Integrator<dim>::bdry, local, std_cxx11::_1, std_cxx11::_2),
-// std_cxx11::bind (&Integrator<dim>::face, local, std_cxx11::_1, std_cxx11::_2, std_cxx11::_3, std_cxx11::_4),
+// std::bind (&Integrator<dim>::cell, local, std::placeholders::_1, std::placeholders::_2),
+// std::bind (&Integrator<dim>::bdry, local, std::placeholders::_1, std::placeholders::_2),
+// std::bind (&Integrator<dim>::face, local, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4),
// local,
// lctrl);
}
// typename identity<ITERATOR>::type end,
// DOFINFO &dinfo,
// INFOBOX &info,
-// const std_cxx11::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &cell_worker,
-// const std_cxx11::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &boundary_worker,
-// const std_cxx11::function<void (DOFINFO &, DOFINFO &,
+// const std::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &cell_worker,
+// const std::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &boundary_worker,
+// const std::function<void (DOFINFO &, DOFINFO &,
// typename INFOBOX::CellInfo &,
// typename INFOBOX::CellInfo &)> &face_worker,
// ASSEMBLER &assembler,
// MeshWorker::loop<dim, dim, MeshWorker::DoFInfo<dim>, MeshWorker::IntegrationInfoBox<dim> >
// (dofs.begin_active(), dofs.end(),
// dof_info, info_box,
-// std_cxx11::bind (&Integrator<dim>::cell, local, std_cxx11::_1, std_cxx11::_2),
-// std_cxx11::bind (&Integrator<dim>::bdry, local, std_cxx11::_1, std_cxx11::_2),
-// std_cxx11::bind (&Integrator<dim>::face, local, std_cxx11::_1, std_cxx11::_2, std_cxx11::_3, std_cxx11::_4),
+// std::bind (&Integrator<dim>::cell, local, std::placeholders::_1, std::placeholders::_2),
+// std::bind (&Integrator<dim>::bdry, local, std::placeholders::_1, std::placeholders::_2),
+// std::bind (&Integrator<dim>::face, local, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4),
// local,
// lctrl);
}
// typename identity<ITERATOR>::type end,
// DOFINFO &dinfo,
// INFOBOX &info,
-// const std_cxx11::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &cell_worker,
-// const std_cxx11::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &boundary_worker,
-// const std_cxx11::function<void (DOFINFO &, DOFINFO &,
+// const std::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &cell_worker,
+// const std::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &boundary_worker,
+// const std::function<void (DOFINFO &, DOFINFO &,
// typename INFOBOX::CellInfo &,
// typename INFOBOX::CellInfo &)> &face_worker,
// ASSEMBLER &assembler,
// MeshWorker::loop<dim, dim, MeshWorker::DoFInfo<dim>, MeshWorker::IntegrationInfoBox<dim> >
// (dofs.begin_active(), dofs.end(),
// dof_info, info_box,
-// std_cxx11::bind (&Integrator<dim>::cell, local, std_cxx11::_1, std_cxx11::_2),
-// std_cxx11::bind (&Integrator<dim>::bdry, local, std_cxx11::_1, std_cxx11::_2),
-// std_cxx11::bind (&Integrator<dim>::face, local, std_cxx11::_1, std_cxx11::_2, std_cxx11::_3, std_cxx11::_4),
+// std::bind (&Integrator<dim>::cell, local, std::placeholders::_1, std::placeholders::_2),
+// std::bind (&Integrator<dim>::bdry, local, std::placeholders::_1, std::placeholders::_2),
+// std::bind (&Integrator<dim>::face, local, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4),
// local,
// lctrl);
}
// typename identity<ITERATOR>::type end,
// DOFINFO &dinfo,
// INFOBOX &info,
-// const std_cxx11::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &cell_worker,
-// const std_cxx11::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &boundary_worker,
-// const std_cxx11::function<void (DOFINFO &, DOFINFO &,
+// const std::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &cell_worker,
+// const std::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &boundary_worker,
+// const std::function<void (DOFINFO &, DOFINFO &,
// typename INFOBOX::CellInfo &,
// typename INFOBOX::CellInfo &)> &face_worker,
// ASSEMBLER &assembler,
// MeshWorker::loop<dim, dim, MeshWorker::DoFInfo<dim>, MeshWorker::IntegrationInfoBox<dim> >
// (dofs.begin_active(), dofs.end(),
// dof_info, info_box,
-// std_cxx11::bind (&Integrator<dim>::cell, local, std_cxx11::_1, std_cxx11::_2),
-// std_cxx11::bind (&Integrator<dim>::bdry, local, std_cxx11::_1, std_cxx11::_2),
-// std_cxx11::bind (&Integrator<dim>::face, local, std_cxx11::_1, std_cxx11::_2, std_cxx11::_3, std_cxx11::_4),
+// std::bind (&Integrator<dim>::cell, local, std::placeholders::_1, std::placeholders::_2),
+// std::bind (&Integrator<dim>::bdry, local, std::placeholders::_1, std::placeholders::_2),
+// std::bind (&Integrator<dim>::face, local, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4),
// local,
// lctrl);
}
#include <deal.II/meshworker/assembler.h>
#include <deal.II/meshworker/loop.h>
-#include <deal.II/base/std_cxx11/function.h>
#include <deal.II/base/logstream.h>
#include <deal.II/lac/sparsity_pattern.h>
#include <deal.II/lac/sparse_matrix.h>
#include <deal.II/fe/fe_system.h>
#include <fstream>
+#include <functional>
#include <iomanip>
using namespace dealii;
MeshWorker::loop<dim, dim, MeshWorker::DoFInfo<dim>, MeshWorker::IntegrationInfoBox<dim> >
(cell, end,
dof_info, info_box,
- std_cxx11::bind (&Local<dim>::cell, local, std_cxx11::_1, std_cxx11::_2),
- std_cxx11::bind (&Local<dim>::bdry, local, std_cxx11::_1, std_cxx11::_2),
- std_cxx11::bind (&Local<dim>::face, local, std_cxx11::_1, std_cxx11::_2, std_cxx11::_3, std_cxx11::_4),
+ std::bind (&Local<dim>::cell, local, std::placeholders::_1, std::placeholders::_2),
+ std::bind (&Local<dim>::bdry, local, std::placeholders::_1, std::placeholders::_2),
+ std::bind (&Local<dim>::face, local, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4),
assembler, lctrl);
matrix.compress(VectorOperation::add);
#include <deal.II/grid/tria.h>
#include <deal.II/distributed/tria.h>
#include <deal.II/grid/grid_generator.h>
-#include <deal.II/base/std_cxx11/bind.h>
#include <fstream>
+#include <functional>
#include <ostream>
// Test on whether signals post_refinement_on_cell and pre_coarsening_on_cell
tria(tria_in)
{
tria_in.signals.post_refinement_on_cell.connect
- (std_cxx11::bind (&SignalListener<dim, spacedim>::count_on_refine,
- this,
- std_cxx11::placeholders::_1));
+ (std::bind (&SignalListener<dim, spacedim>::count_on_refine,
+ this,
+ std::placeholders::_1));
tria_in.signals.pre_coarsening_on_cell.connect
- (std_cxx11::bind (&SignalListener<dim, spacedim>::count_on_coarsen,
- this,
- std_cxx11::placeholders::_1));
+ (std::bind (&SignalListener<dim, spacedim>::count_on_coarsen,
+ this,
+ std::placeholders::_1));
}
int n_active_cell_gap()
#include <deal.II/grid/tria.h>
#include <deal.II/distributed/tria.h>
#include <deal.II/grid/grid_generator.h>
-#include <deal.II/base/std_cxx11/bind.h>
#include <fstream>
+#include <functional>
#include <ostream>
// Test on whether signals post_refinement_on_cell and pre_coarsening_on_cell
tria(tria_in)
{
tria_in.signals.post_refinement_on_cell.connect
- (std_cxx11::bind (&SignalListener<dim, spacedim>::count_on_refine,
- this,
- std_cxx11::placeholders::_1));
+ (std::bind (&SignalListener<dim, spacedim>::count_on_refine,
+ this,
+ std::placeholders::_1));
tria_in.signals.pre_coarsening_on_cell.connect
- (std_cxx11::bind (&SignalListener<dim, spacedim>::count_on_coarsen,
- this,
- std_cxx11::placeholders::_1));
+ (std::bind (&SignalListener<dim, spacedim>::count_on_coarsen,
+ this,
+ std::placeholders::_1));
}
int n_active_cell_gap()
#include <deal.II/grid/tria.h>
#include <deal.II/distributed/tria.h>
#include <deal.II/grid/grid_generator.h>
-#include <deal.II/base/std_cxx11/bind.h>
#include <fstream>
+#include <functional>
#include <ostream>
// Test on whether signals post_refinement_on_cell and pre_coarsening_on_cell
tria(tria_in)
{
tria_in.signals.post_refinement_on_cell.connect
- (std_cxx11::bind (&SignalListener<dim, spacedim>::count_on_refine,
- this,
- std_cxx11::placeholders::_1));
+ (std::bind (&SignalListener<dim, spacedim>::count_on_refine,
+ this,
+ std::placeholders::_1));
tria_in.signals.pre_coarsening_on_cell.connect
- (std_cxx11::bind (&SignalListener<dim, spacedim>::count_on_coarsen,
- this,
- std_cxx11::placeholders::_1));
+ (std::bind (&SignalListener<dim, spacedim>::count_on_coarsen,
+ this,
+ std::placeholders::_1));
}
int n_active_cell_gap()
#include <deal.II/grid/tria.h>
#include <deal.II/distributed/tria.h>
#include <deal.II/grid/grid_generator.h>
-#include <deal.II/base/std_cxx11/bind.h>
#include <fstream>
+#include <functional>
#include <ostream>
// Test on whether signals post_refinement_on_cell and pre_coarsening_on_cell
tria(tria_in)
{
tria_in.signals.post_refinement_on_cell.connect
- (std_cxx11::bind (&SignalListener<dim, spacedim>::count_on_refine,
- this,
- std_cxx11::placeholders::_1));
+ (std::bind (&SignalListener<dim, spacedim>::count_on_refine,
+ this,
+ std::placeholders::_1));
tria_in.signals.pre_coarsening_on_cell.connect
- (std_cxx11::bind (&SignalListener<dim, spacedim>::count_on_coarsen,
- this,
- std_cxx11::placeholders::_1));
+ (std::bind (&SignalListener<dim, spacedim>::count_on_coarsen,
+ this,
+ std::placeholders::_1));
}
int n_active_cell_gap()
#include <deal.II/grid/tria.h>
#include <deal.II/distributed/tria.h>
#include <deal.II/grid/grid_generator.h>
-#include <deal.II/base/std_cxx11/bind.h>
#include <fstream>
+#include <functional>
#include <ostream>
// This is a test for test driver itself. Signals on refinement is disabled,
tria(tria_in)
{
// tria_in.signals.post_refinement_on_cell.connect
- // (std_cxx11::bind (&SignalListener<dim, spacedim>::count_on_refine,
+ // (std::bind (&SignalListener<dim, spacedim>::count_on_refine,
// this,
- // std_cxx11::placeholders::_1));
+ // std::placeholders::_1));
tria_in.signals.pre_coarsening_on_cell.connect
- (std_cxx11::bind (&SignalListener<dim, spacedim>::count_on_coarsen,
- this,
- std_cxx11::placeholders::_1));
+ (std::bind (&SignalListener<dim, spacedim>::count_on_coarsen,
+ this,
+ std::placeholders::_1));
}
int n_active_cell_gap()
#include <deal.II/multigrid/mg_matrix.h>
#include <fstream>
+#include <functional>
#include <sstream>
-#include <deal.II/base/std_cxx11/bind.h>
using namespace dealii;
MeshWorker::loop<dim, dim, MeshWorker::DoFInfo<dim>, MeshWorker::IntegrationInfoBox<dim> > (
dof.begin_mg(l), dof.end_mg(l),
dof_info, info_box,
- std_cxx11::bind(&OutputCreator<dim>::cell, &matrix_integrator, std_cxx11::_1, std_cxx11::_2),
+ std::bind(&OutputCreator<dim>::cell, &matrix_integrator, std::placeholders::_1, std::placeholders::_2),
0,
0,
assembler);
#include <deal.II/multigrid/mg_matrix.h>
#include <fstream>
+#include <functional>
#include <sstream>
-#include <deal.II/base/std_cxx11/bind.h>
using namespace dealii;
MeshWorker::loop<dim, dim, MeshWorker::DoFInfo<dim>, MeshWorker::IntegrationInfoBox<dim> > (
dof.begin_mg(l), dof.end_mg(l),
dof_info, info_box,
- std_cxx11::bind(&OutputCreator<dim>::cell, &matrix_integrator, std_cxx11::_1, std_cxx11::_2),
+ std::bind(&OutputCreator<dim>::cell, &matrix_integrator, std::placeholders::_1, std::placeholders::_2),
0,
0,
assembler);
constraints.close ();
graph = GraphColoring::make_graph_coloring(dof_handler.begin_active(),dof_handler.end(),
- static_cast<std_cxx11::function<std::vector<types::global_dof_index>
+ static_cast<std::function<std::vector<types::global_dof_index>
(typename hp::DoFHandler<dim>::active_cell_iterator const &)> >
- (std_cxx11::bind(&LaplaceProblem<dim>::get_conflict_indices, this,std_cxx11::_1)));
+ (std::bind(&LaplaceProblem<dim>::get_conflict_indices, this,std::placeholders::_1)));
DynamicSparsityPattern csp (dof_handler.n_dofs(),
WorkStream::
run (graph,
- std_cxx11::bind (&LaplaceProblem<dim>::
- local_assemble,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3),
- std_cxx11::bind (&LaplaceProblem<dim>::
- copy_local_to_global,
- this,
- std_cxx11::_1),
+ std::bind (&LaplaceProblem<dim>::
+ local_assemble,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3),
+ std::bind (&LaplaceProblem<dim>::
+ copy_local_to_global,
+ this,
+ std::placeholders::_1),
Assembly::Scratch::Data<dim>(fe_collection, quadrature_collection),
Assembly::Copy::Data ());
constraints.close ();
graph = GraphColoring::make_graph_coloring(dof_handler.begin_active(),dof_handler.end(),
- static_cast<std_cxx11::function<std::vector<types::global_dof_index>
+ static_cast<std::function<std::vector<types::global_dof_index>
(typename hp::DoFHandler<dim>::active_cell_iterator const &)> >
- (std_cxx11::bind(&LaplaceProblem<dim>::get_conflict_indices, this,std_cxx11::_1)));
+ (std::bind(&LaplaceProblem<dim>::get_conflict_indices, this,std::placeholders::_1)));
DynamicSparsityPattern csp (dof_handler.n_dofs(),
WorkStream::
run (graph,
- std_cxx11::bind (&LaplaceProblem<dim>::
- local_assemble,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3),
- std_cxx11::bind (&LaplaceProblem<dim>::
- copy_local_to_global,
- this,
- std_cxx11::_1),
+ std::bind (&LaplaceProblem<dim>::
+ local_assemble,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3),
+ std::bind (&LaplaceProblem<dim>::
+ copy_local_to_global,
+ this,
+ std::placeholders::_1),
Assembly::Scratch::Data<dim>(fe_collection, quadrature_collection),
Assembly::Copy::Data (),
MultithreadInfo::n_threads(),
WorkStream::
run (graph,
- std_cxx11::bind (&LaplaceProblem<dim>::
- local_assemble,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3),
- std_cxx11::bind (&LaplaceProblem<dim>::
- copy_local_to_global,
- this,
- std_cxx11::_1),
+ std::bind (&LaplaceProblem<dim>::
+ local_assemble,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3),
+ std::bind (&LaplaceProblem<dim>::
+ copy_local_to_global,
+ this,
+ std::placeholders::_1),
Assembly::Scratch::Data<dim>(fe_collection, quadrature_collection),
Assembly::Copy::Data (true),
2*MultithreadInfo::n_threads(),
constraints.close ();
graph = GraphColoring::make_graph_coloring(dof_handler.begin_active(),dof_handler.end(),
- static_cast<std_cxx11::function<std::vector<types::global_dof_index>
+ static_cast<std::function<std::vector<types::global_dof_index>
(typename hp::DoFHandler<dim>::active_cell_iterator const &)> >
- (std_cxx11::bind(&LaplaceProblem<dim>::get_conflict_indices, this,std_cxx11::_1)));
+ (std::bind(&LaplaceProblem<dim>::get_conflict_indices, this,std::placeholders::_1)));
BlockDynamicSparsityPattern csp (2, 2);
WorkStream::
run (graph,
- std_cxx11::bind (&LaplaceProblem<dim>::
- local_assemble,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3),
- std_cxx11::bind (&LaplaceProblem<dim>::
- copy_local_to_global,
- this,
- std_cxx11::_1),
+ std::bind (&LaplaceProblem<dim>::
+ local_assemble,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3),
+ std::bind (&LaplaceProblem<dim>::
+ copy_local_to_global,
+ this,
+ std::placeholders::_1),
Assembly::Scratch::Data<dim>(fe_collection, quadrature_collection),
Assembly::Copy::Data ());
constraints.close ();
graph = GraphColoring::make_graph_coloring(dof_handler.begin_active(),dof_handler.end(),
- static_cast<std_cxx11::function<std::vector<types::global_dof_index>
+ static_cast<std::function<std::vector<types::global_dof_index>
(typename hp::DoFHandler<dim>::active_cell_iterator const &)> >
- (std_cxx11::bind(&LaplaceProblem<dim>::get_conflict_indices, this,std_cxx11::_1)));
+ (std::bind(&LaplaceProblem<dim>::get_conflict_indices, this,std::placeholders::_1)));
DynamicSparsityPattern csp (dof_handler.n_dofs(),
WorkStream::
run (graph,
- std_cxx11::bind (&LaplaceProblem<dim>::
- local_assemble,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3),
- std_cxx11::bind (&LaplaceProblem<dim>::
- copy_local_to_global,
- this,
- std_cxx11::_1),
+ std::bind (&LaplaceProblem<dim>::
+ local_assemble,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3),
+ std::bind (&LaplaceProblem<dim>::
+ copy_local_to_global,
+ this,
+ std::placeholders::_1),
Assembly::Scratch::Data<dim>(fe_collection, quadrature_collection),
Assembly::Copy::Data (1),
2*MultithreadInfo::n_threads(),
WorkStream::
run (graph,
- std_cxx11::bind (&LaplaceProblem<dim>::
- local_assemble,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3),
- std_cxx11::bind (&LaplaceProblem<dim>::
- copy_local_to_global,
- this,
- std_cxx11::_1),
+ std::bind (&LaplaceProblem<dim>::
+ local_assemble,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3),
+ std::bind (&LaplaceProblem<dim>::
+ copy_local_to_global,
+ this,
+ std::placeholders::_1),
Assembly::Scratch::Data<dim>(fe_collection, quadrature_collection),
Assembly::Copy::Data (2),
2*MultithreadInfo::n_threads(),
return DataOut<dim>::get_dataset_names();
}
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> >
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> >
get_vector_data_ranges () const
{
// if we have enough components for a
// vector solution, make the last dim
// components a vector
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> >
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> >
retval;
if (get_dataset_names().size() >= dim)
- retval.push_back (std_cxx11::tuple
+ retval.push_back (std::tuple
<unsigned int, unsigned int, std::string>
(get_dataset_names().size()-dim,
get_dataset_names().size()-1,
return DataOutReader<dim>::get_dataset_names();
}
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> >
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> >
get_vector_data_ranges () const
{
return DataOutReader<dim>::get_vector_data_ranges ();
ExcInternalError());
for (unsigned int i=0; i<data_out.get_vector_data_ranges().size(); ++i)
{
- deallog << std_cxx11::get<0>(data_out.get_vector_data_ranges()[i])
+ deallog << std::get<0>(data_out.get_vector_data_ranges()[i])
<< ' '
- << std_cxx11::get<1>(data_out.get_vector_data_ranges()[i])
+ << std::get<1>(data_out.get_vector_data_ranges()[i])
<< ' '
- << std_cxx11::get<2>(data_out.get_vector_data_ranges()[i])
+ << std::get<2>(data_out.get_vector_data_ranges()[i])
<< std::endl;
- Assert (std_cxx11::get<0>(data_out.get_vector_data_ranges()[i])
+ Assert (std::get<0>(data_out.get_vector_data_ranges()[i])
==
- std_cxx11::get<0>(reader.get_vector_data_ranges()[i]),
+ std::get<0>(reader.get_vector_data_ranges()[i]),
ExcInternalError());
- Assert (std_cxx11::get<1>(data_out.get_vector_data_ranges()[i])
+ Assert (std::get<1>(data_out.get_vector_data_ranges()[i])
==
- std_cxx11::get<1>(reader.get_vector_data_ranges()[i]),
+ std::get<1>(reader.get_vector_data_ranges()[i]),
ExcInternalError());
- Assert (std_cxx11::get<2>(data_out.get_vector_data_ranges()[i])
+ Assert (std::get<2>(data_out.get_vector_data_ranges()[i])
==
- std_cxx11::get<2>(reader.get_vector_data_ranges()[i]),
+ std::get<2>(reader.get_vector_data_ranges()[i]),
ExcInternalError());
}
return DataOutFaces<dim>::get_dataset_names();
}
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> >
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> >
get_vector_data_ranges () const
{
return DataOutFaces<dim>::get_vector_data_ranges ();
return DataOutReader<dim-1,dim>::get_dataset_names();
}
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> >
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> >
get_vector_data_ranges () const
{
return DataOutReader<dim-1,dim>::get_vector_data_ranges ();
ExcInternalError());
for (unsigned int i=0; i<data_out.get_vector_data_ranges().size(); ++i)
{
- deallog << std_cxx11::get<0>(data_out.get_vector_data_ranges()[i])
+ deallog << std::get<0>(data_out.get_vector_data_ranges()[i])
<< ' '
- << std_cxx11::get<1>(data_out.get_vector_data_ranges()[i])
+ << std::get<1>(data_out.get_vector_data_ranges()[i])
<< ' '
- << std_cxx11::get<2>(data_out.get_vector_data_ranges()[i])
+ << std::get<2>(data_out.get_vector_data_ranges()[i])
<< std::endl;
- Assert (std_cxx11::get<0>(data_out.get_vector_data_ranges()[i])
+ Assert (std::get<0>(data_out.get_vector_data_ranges()[i])
==
- std_cxx11::get<0>(reader.get_vector_data_ranges()[i]),
+ std::get<0>(reader.get_vector_data_ranges()[i]),
ExcInternalError());
- Assert (std_cxx11::get<1>(data_out.get_vector_data_ranges()[i])
+ Assert (std::get<1>(data_out.get_vector_data_ranges()[i])
==
- std_cxx11::get<1>(reader.get_vector_data_ranges()[i]),
+ std::get<1>(reader.get_vector_data_ranges()[i]),
ExcInternalError());
- Assert (std_cxx11::get<2>(data_out.get_vector_data_ranges()[i])
+ Assert (std::get<2>(data_out.get_vector_data_ranges()[i])
==
- std_cxx11::get<2>(reader.get_vector_data_ranges()[i]),
+ std::get<2>(reader.get_vector_data_ranges()[i]),
ExcInternalError());
}
return DataOutRotation<dim>::get_dataset_names();
}
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> >
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> >
get_vector_data_ranges () const
{
return DataOutRotation<dim>::get_vector_data_ranges ();
return DataOutReader<dim+1>::get_dataset_names();
}
- std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> >
+ std::vector<std::tuple<unsigned int, unsigned int, std::string> >
get_vector_data_ranges () const
{
return DataOutReader<dim+1>::get_vector_data_ranges ();
ExcInternalError());
for (unsigned int i=0; i<data_out.get_vector_data_ranges().size(); ++i)
{
- deallog << std_cxx11::get<0>(data_out.get_vector_data_ranges()[i])
+ deallog << std::get<0>(data_out.get_vector_data_ranges()[i])
<< ' '
- << std_cxx11::get<1>(data_out.get_vector_data_ranges()[i])
+ << std::get<1>(data_out.get_vector_data_ranges()[i])
<< ' '
- << std_cxx11::get<2>(data_out.get_vector_data_ranges()[i])
+ << std::get<2>(data_out.get_vector_data_ranges()[i])
<< std::endl;
- Assert (std_cxx11::get<0>(data_out.get_vector_data_ranges()[i])
+ Assert (std::get<0>(data_out.get_vector_data_ranges()[i])
==
- std_cxx11::get<0>(reader.get_vector_data_ranges()[i]),
+ std::get<0>(reader.get_vector_data_ranges()[i]),
ExcInternalError());
- Assert (std_cxx11::get<1>(data_out.get_vector_data_ranges()[i])
+ Assert (std::get<1>(data_out.get_vector_data_ranges()[i])
==
- std_cxx11::get<1>(reader.get_vector_data_ranges()[i]),
+ std::get<1>(reader.get_vector_data_ranges()[i]),
ExcInternalError());
- Assert (std_cxx11::get<2>(data_out.get_vector_data_ranges()[i])
+ Assert (std::get<2>(data_out.get_vector_data_ranges()[i])
==
- std_cxx11::get<2>(reader.get_vector_data_ranges()[i]),
+ std::get<2>(reader.get_vector_data_ranges()[i]),
ExcInternalError());
}
typename MatrixFree<dim,double>::AdditionalData additional_data;
additional_data.tasks_parallel_scheme = MatrixFree<dim,double>::AdditionalData::partition_color;
additional_data.mapping_update_flags = update_values | update_JxW_values | update_quadrature_points;
- std_cxx11::shared_ptr<MatrixFree<dim,double> > data(new MatrixFree<dim,double> ());
+ std::shared_ptr<MatrixFree<dim,double> > data(new MatrixFree<dim,double> ());
data->reinit (dof_handler, constraints, quadrature_formula_1d, additional_data);
for (unsigned int q=0; q<=p; ++q)
TopoDS_Shape sh;
for (unsigned int i=0; i<points.size(); ++i)
{
- std
_cxx11::tuple<Point<3>, TopoDS_Shape, double, double> ref =
+ std::tuple<Point<3>, TopoDS_Shape, double, double> ref =
project_point_and_pull_back(edge, points[i]);
- Point<3> pp = std_cxx11::get<0>(ref);
- sh = std_cxx11::get<1>(ref);
- u = std_cxx11::get<2>(ref);
- v = std_cxx11::get<3>(ref);
+ Point<3> pp = std::get<0>(ref);
+ sh = std::get<1>(ref);
+ u = std::get<2>(ref);
+ v = std::get<3>(ref);
deallog << "Origin: " << points[i]
<< ", on unit circle: " << pp
extract_geometrical_shapes(sh, faces, edges, vertices);
- std_cxx11::tuple<unsigned int, unsigned int, unsigned int>
+ std::tuple<unsigned int, unsigned int, unsigned int>
n = count_elements(sh);
- unsigned int nf=std_cxx11::get<0>(n);
- unsigned int ne=std_cxx11::get<1>(n);
- unsigned int nv=std_cxx11::get<2>(n);
+ unsigned int nf=std::get<0>(n);
+ unsigned int ne=std::get<1>(n);
+ unsigned int nv=std::get<2>(n);
- deallog << "Shape contains " << std_cxx11::get<0>(n) << " faces, "
- << std_cxx11::get<1>(n) << " edges, and "
- << std_cxx11::get<2>(n) << " vertices." << std::endl;
+ deallog << "Shape contains " << std::get<0>(n) << " faces, "
+ << std::get<1>(n) << " edges, and "
+ << std::get<2>(n) << " vertices." << std::endl;
if (nf != faces.size())
deallog << "Error!" << std::endl;
extract_geometrical_shapes(sh, faces, edges, vertices);
- std_cxx11::tuple<unsigned int, unsigned int, unsigned int>
+ std::tuple<unsigned int, unsigned int, unsigned int>
n = count_elements(sh);
- unsigned int nf=std_cxx11::get<0>(n);
- unsigned int ne=std_cxx11::get<1>(n);
- unsigned int nv=std_cxx11::get<2>(n);
+ unsigned int nf=std::get<0>(n);
+ unsigned int ne=std::get<1>(n);
+ unsigned int nv=std::get<2>(n);
- deallog << "Shape contains " << std_cxx11::get<0>(n) << " faces, "
- << std_cxx11::get<1>(n) << " edges, and "
- << std_cxx11::get<2>(n) << " vertices." << std::endl;
+ deallog << "Shape contains " << std::get<0>(n) << " faces, "
+ << std::get<1>(n) << " edges, and "
+ << std::get<2>(n) << " vertices." << std::endl;
if (nf != faces.size())
deallog << "Error!" << std::endl;
// check std::transform
std::transform (v1.begin(), v1.end(), v2.begin(),
- std_cxx11::bind (std::multiplies<double>(),
- std_cxx11::_1,
- 2.0));
+ std::bind (std::multiplies<double>(),
+ std::placeholders::_1,
+ 2.0));
v2 *= 1./2.;
deallog << "Check 7: " << (v1 == v2 ? "true" : "false") << std::endl;
return Jc;
}
private:
- std_cxx11::shared_ptr< Material_Compressible_Neo_Hook_Three_Field<dim> > material;
+ std::shared_ptr< Material_Compressible_Neo_Hook_Three_Field<dim> > material;
Tensor<2, dim> F_inv;
SymmetricTensor<2, dim> tau;
double d2Psi_vol_dJ2;
ScratchData_K scratch_data(fe, qf_cell, uf_cell);
WorkStream::run(dof_handler_ref.begin_active(),
dof_handler_ref.end(),
- std_cxx11::bind(&Solid<dim>::assemble_system_tangent_one_cell,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3),
- std_cxx11::bind(&Solid<dim>::copy_local_to_global_K,
- this,
- std_cxx11::_1),
+ std::bind(&Solid<dim>::assemble_system_tangent_one_cell,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3),
+ std::bind(&Solid<dim>::copy_local_to_global_K,
+ this,
+ std::placeholders::_1),
scratch_data,
per_task_data);
timer.leave_subsection();
ScratchData_RHS scratch_data(fe, qf_cell, uf_cell, qf_face, uf_face);
WorkStream::run(dof_handler_ref.begin_active(),
dof_handler_ref.end(),
- std_cxx11::bind(&Solid<dim>::assemble_system_rhs_one_cell,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3),
- std_cxx11::bind(&Solid<dim>::copy_local_to_global_rhs,
- this,
- std_cxx11::_1),
+ std::bind(&Solid<dim>::assemble_system_rhs_one_cell,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3),
+ std::bind(&Solid<dim>::copy_local_to_global_rhs,
+ this,
+ std::placeholders::_1),
scratch_data,
per_task_data);
timer.leave_subsection();
return Jc;
}
private:
- std_cxx11::shared_ptr< Material_Compressible_Neo_Hook_Three_Field<dim> > material;
+ std::shared_ptr< Material_Compressible_Neo_Hook_Three_Field<dim> > material;
Tensor<2, dim> F_inv;
SymmetricTensor<2, dim> tau;
double d2Psi_vol_dJ2;
ScratchData_K scratch_data(fe, qf_cell, uf_cell);
WorkStream::run(dof_handler_ref.begin_active(),
dof_handler_ref.end(),
- std_cxx11::bind(&Solid<dim>::assemble_system_tangent_one_cell,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3),
- std_cxx11::bind(&Solid<dim>::copy_local_to_global_K,
- this,
- std_cxx11::_1),
+ std::bind(&Solid<dim>::assemble_system_tangent_one_cell,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3),
+ std::bind(&Solid<dim>::copy_local_to_global_K,
+ this,
+ std::placeholders::_1),
scratch_data,
per_task_data);
timer.leave_subsection();
ScratchData_RHS scratch_data(fe, qf_cell, uf_cell, qf_face, uf_face);
WorkStream::run(dof_handler_ref.begin_active(),
dof_handler_ref.end(),
- std_cxx11::bind(&Solid<dim>::assemble_system_rhs_one_cell,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3),
- std_cxx11::bind(&Solid<dim>::copy_local_to_global_rhs,
- this,
- std_cxx11::_1),
+ std::bind(&Solid<dim>::assemble_system_rhs_one_cell,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3),
+ std::bind(&Solid<dim>::copy_local_to_global_rhs,
+ this,
+ std::placeholders::_1),
scratch_data,
per_task_data);
timer.leave_subsection();
return Jc;
}
private:
- std_cxx11::shared_ptr< Material_Compressible_Neo_Hook_Three_Field<dim> > material;
+ std::shared_ptr< Material_Compressible_Neo_Hook_Three_Field<dim> > material;
Tensor<2, dim> F_inv;
SymmetricTensor<2, dim> tau;
double d2Psi_vol_dJ2;
ScratchData_K scratch_data(fe, qf_cell, uf_cell);
WorkStream::run(dof_handler_ref.begin_active(),
dof_handler_ref.end(),
- std_cxx11::bind(&Solid<dim>::assemble_system_tangent_one_cell,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3),
- std_cxx11::bind(&Solid<dim>::copy_local_to_global_K,
- this,
- std_cxx11::_1),
+ std::bind(&Solid<dim>::assemble_system_tangent_one_cell,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3),
+ std::bind(&Solid<dim>::copy_local_to_global_K,
+ this,
+ std::placeholders::_1),
scratch_data,
per_task_data);
timer.leave_subsection();
ScratchData_RHS scratch_data(fe, qf_cell, uf_cell, qf_face, uf_face);
WorkStream::run(dof_handler_ref.begin_active(),
dof_handler_ref.end(),
- std_cxx11::bind(&Solid<dim>::assemble_system_rhs_one_cell,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3),
- std_cxx11::bind(&Solid<dim>::copy_local_to_global_rhs,
- this,
- std_cxx11::_1),
+ std::bind(&Solid<dim>::assemble_system_rhs_one_cell,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3),
+ std::bind(&Solid<dim>::copy_local_to_global_rhs,
+ this,
+ std::placeholders::_1),
scratch_data,
per_task_data);
timer.leave_subsection();
WorkStream::run(v.begin(),
v.end(),
&assemble,
- std_cxx11::bind(©,
- std_cxx11::ref(result),
- std_cxx11::_1),
+ std::bind(©,
+ std::ref(result),
+ std::placeholders::_1),
scratch_data(), copy_data());
std::cout << "result: " << result << std::endl;
constraints.close ();
graph = GraphColoring::make_graph_coloring(dof_handler.begin_active(),dof_handler.end(),
- static_cast<std_cxx11::function<std::vector<types::global_dof_index>
+ static_cast<std::function<std::vector<types::global_dof_index>
(typename hp::DoFHandler<dim>::active_cell_iterator const &)> >
- (std_cxx11::bind(&LaplaceProblem<dim>::get_conflict_indices, this,std_cxx11::_1)));
+ (std::bind(&LaplaceProblem<dim>::get_conflict_indices, this,std::placeholders::_1)));
DynamicSparsityPattern csp (dof_handler.n_dofs(),
WorkStream::
run (graph,
- std_cxx11::bind (&LaplaceProblem<dim>::
- local_assemble,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3),
- std_cxx11::bind (&LaplaceProblem<dim>::
- copy_local_to_global,
- this,
- std_cxx11::_1),
+ std::bind (&LaplaceProblem<dim>::
+ local_assemble,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3),
+ std::bind (&LaplaceProblem<dim>::
+ copy_local_to_global,
+ this,
+ std::placeholders::_1),
Assembly::Scratch::Data<dim>(fe_collection, quadrature_collection),
Assembly::Copy::Data (),
2*MultithreadInfo::n_threads(),
CellFilter begin(IteratorFilters::LocallyOwnedCell(),dof_handler.begin_active());
CellFilter end(IteratorFilters::LocallyOwnedCell(),dof_handler.end());
graph = GraphColoring::make_graph_coloring(begin,end,
- static_cast<std_cxx11::function<std::vector<types::global_dof_index>
+ static_cast<std::function<std::vector<types::global_dof_index>
(FilteredIterator<typename DoFHandler<dim>::active_cell_iterator> const &)> >
- (std_cxx11::bind(&LaplaceProblem<dim>::get_conflict_indices, this,std_cxx11::_1)));
+ (std::bind(&LaplaceProblem<dim>::get_conflict_indices, this,std::placeholders::_1)));
IndexSet locally_owned = dof_handler.locally_owned_dofs();
{
WorkStream::
run (graph,
- std_cxx11::bind (&LaplaceProblem<dim>::
- local_assemble,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3),
- std_cxx11::bind (&LaplaceProblem<dim>::
- copy_local_to_global,
- this,
- std_cxx11::_1),
+ std::bind (&LaplaceProblem<dim>::
+ local_assemble,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3),
+ std::bind (&LaplaceProblem<dim>::
+ copy_local_to_global,
+ this,
+ std::placeholders::_1),
Assembly::Scratch::Data<dim>(fe, quadrature),
Assembly::Copy::Data (false),
2*MultithreadInfo::n_threads(),
CellFilter begin(IteratorFilters::LocallyOwnedCell(),dof_handler.begin_active());
CellFilter end(IteratorFilters::LocallyOwnedCell(),dof_handler.end());
graph = GraphColoring::make_graph_coloring(begin,end,
- static_cast<std_cxx11::function<std::vector<types::global_dof_index>
+ static_cast<std::function<std::vector<types::global_dof_index>
(FilteredIterator<typename DoFHandler<dim>::active_cell_iterator> const &)> >
- (std_cxx11::bind(&LaplaceProblem<dim>::get_conflict_indices, this,std_cxx11::_1)));
+ (std::bind(&LaplaceProblem<dim>::get_conflict_indices, this,std::placeholders::_1)));
IndexSet locally_owned = dof_handler.locally_owned_dofs();
{
WorkStream::
run (graph,
- std_cxx11::bind (&LaplaceProblem<dim>::
- local_assemble,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3),
- std_cxx11::bind (&LaplaceProblem<dim>::
- copy_local_to_global,
- this,
- std_cxx11::_1),
+ std::bind (&LaplaceProblem<dim>::
+ local_assemble,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3),
+ std::bind (&LaplaceProblem<dim>::
+ copy_local_to_global,
+ this,
+ std::placeholders::_1),
Assembly::Scratch::Data<dim>(fe, quadrature),
Assembly::Copy::Data (false),
2*MultithreadInfo::n_threads(),
CellFilter begin(IteratorFilters::LocallyOwnedCell(),dof_handler.begin_active());
CellFilter end(IteratorFilters::LocallyOwnedCell(),dof_handler.end());
graph = GraphColoring::make_graph_coloring(begin,end,
- static_cast<std_cxx11::function<std::vector<types::global_dof_index>
+ static_cast<std::function<std::vector<types::global_dof_index>
(FilteredIterator<typename DoFHandler<dim>::active_cell_iterator> const &)> >
- (std_cxx11::bind(&LaplaceProblem<dim>::get_conflict_indices, this,std_cxx11::_1)));
+ (std::bind(&LaplaceProblem<dim>::get_conflict_indices, this,std::placeholders::_1)));
TrilinosWrappers::BlockSparsityPattern csp(2,2);
std::vector<IndexSet> locally_owned(2), relevant_set(2);
WorkStream::
run (graph,
- std_cxx11::bind (&LaplaceProblem<dim>::
- local_assemble,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3),
- std_cxx11::bind (&LaplaceProblem<dim>::
- copy_local_to_global,
- this,
- std_cxx11::_1),
+ std::bind (&LaplaceProblem<dim>::
+ local_assemble,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3),
+ std::bind (&LaplaceProblem<dim>::
+ copy_local_to_global,
+ this,
+ std::placeholders::_1),
Assembly::Scratch::Data<dim>(fe, quadrature),
Assembly::Copy::Data (false),
2*MultithreadInfo::n_threads(),
CellFilter begin(IteratorFilters::LocallyOwnedCell(),dof_handler.begin_active());
CellFilter end(IteratorFilters::LocallyOwnedCell(),dof_handler.end());
graph = GraphColoring::make_graph_coloring(begin,end,
- static_cast<std_cxx11::function<std::vector<types::global_dof_index>
+ static_cast<std::function<std::vector<types::global_dof_index>
(FilteredIterator<typename DoFHandler<dim>::active_cell_iterator> const &)> >
- (std_cxx11::bind(&LaplaceProblem<dim>::get_conflict_indices, this,std_cxx11::_1)));
+ (std::bind(&LaplaceProblem<dim>::get_conflict_indices, this,std::placeholders::_1)));
IndexSet locally_owned = dof_handler.locally_owned_dofs();
{
WorkStream::
run (graph,
- std_cxx11::bind (&LaplaceProblem<dim>::
- local_assemble,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3),
- std_cxx11::bind (&LaplaceProblem<dim>::
- copy_local_to_global,
- this,
- std_cxx11::_1),
+ std::bind (&LaplaceProblem<dim>::
+ local_assemble,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3),
+ std::bind (&LaplaceProblem<dim>::
+ copy_local_to_global,
+ this,
+ std::placeholders::_1),
Assembly::Scratch::Data<dim>(fe, quadrature),
Assembly::Copy::Data (false),
2*MultithreadInfo::n_threads(),
CellFilter begin(IteratorFilters::LocallyOwnedCell(),dof_handler.begin_active());
CellFilter end(IteratorFilters::LocallyOwnedCell(),dof_handler.end());
graph = GraphColoring::make_graph_coloring(begin,end,
- static_cast<std_cxx11::function<std::vector<types::global_dof_index>
+ static_cast<std::function<std::vector<types::global_dof_index>
(FilteredIterator<typename DoFHandler<dim>::active_cell_iterator> const &)> >
- (std_cxx11::bind(&LaplaceProblem<dim>::get_conflict_indices, this,std_cxx11::_1)));
+ (std::bind(&LaplaceProblem<dim>::get_conflict_indices, this,std::placeholders::_1)));
TrilinosWrappers::BlockSparsityPattern csp(2,2);
std::vector<IndexSet> locally_owned(2), relevant_set(2);
WorkStream::
run (graph,
- std_cxx11::bind (&LaplaceProblem<dim>::
- local_assemble,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3),
- std_cxx11::bind (&LaplaceProblem<dim>::
- copy_local_to_global,
- this,
- std_cxx11::_1),
+ std::bind (&LaplaceProblem<dim>::
+ local_assemble,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3),
+ std::bind (&LaplaceProblem<dim>::
+ copy_local_to_global,
+ this,
+ std::placeholders::_1),
Assembly::Scratch::Data<dim>(fe, quadrature),
Assembly::Copy::Data (false),
2*MultithreadInfo::n_threads(),
CellFilter begin(IteratorFilters::LocallyOwnedCell(),dof_handler.begin_active());
CellFilter end(IteratorFilters::LocallyOwnedCell(),dof_handler.end());
graph = GraphColoring::make_graph_coloring(begin,end,
- static_cast<std_cxx11::function<std::vector<types::global_dof_index>
+ static_cast<std::function<std::vector<types::global_dof_index>
(FilteredIterator<typename DoFHandler<dim>::active_cell_iterator> const &)> >
- (std_cxx11::bind(&LaplaceProblem<dim>::get_conflict_indices, this,std_cxx11::_1)));
+ (std::bind(&LaplaceProblem<dim>::get_conflict_indices, this,std::placeholders::_1)));
IndexSet locally_owned = dof_handler.locally_owned_dofs();
{
WorkStream::
run (graph,
- std_cxx11::bind (&LaplaceProblem<dim>::
- local_assemble,
- this,
- std_cxx11::_1,
- std_cxx11::_2,
- std_cxx11::_3),
- std_cxx11::bind (&LaplaceProblem<dim>::
- copy_local_to_global,
- this,
- std_cxx11::_1),
+ std::bind (&LaplaceProblem<dim>::
+ local_assemble,
+ this,
+ std::placeholders::_1,
+ std::placeholders::_2,
+ std::placeholders::_3),
+ std::bind (&LaplaceProblem<dim>::
+ copy_local_to_global,
+ this,
+ std::placeholders::_1),
Assembly::Scratch::Data<dim>(fe, quadrature),
Assembly::Copy::Data (false),
2*MultithreadInfo::n_threads(),
// check std::transform
std::transform (v1.begin(), v1.end(), v2.begin(),
- std_cxx11::bind (std::multiplies<double>(),
- std_cxx11::_1,
- 2.0));
+ std::bind (std::multiplies<double>(),
+ std::placeholders::_1,
+ 2.0));
v2 *= 1./2.;
deallog << "Check 7: " << (v1 == v2 ? "true" : "false") << std::endl;
projects / dealii.git / commitdiff