Keep the old files and namespace for backward compatibility.
* are available also for pre-C++11 compilers. This is done using
* the following approach:
*
- * - We create a namespace std_cxx1x.
+ * - We create a namespace std_cxx11.
* - If the compiler supports C++11, we import the relevant classes
* and functions into this namespace using statements such as
* @code
- * namespace std_cxx1x { using std::shared_ptr; }
+ * namespace std_cxx11 { using std::shared_ptr; }
* @endcode
* - If the compiler does not support C++11, if its support for
* C++11 is incomplete, or if it is buggy, then we use as a fallback
* <a href="http://www.boost.org">BOOST library</a> through
* statements such as
* @code
- * namespace std_cxx1x { using boost::shared_ptr; }
+ * namespace std_cxx11 { using boost::shared_ptr; }
* @endcode
*
- * Consequently, namespace std_cxx1x contains all of the symbols
+ * Consequently, namespace std_cxx11 contains all of the symbols
* we require. The classes that can be used this way are obviously
* a subset of the intersection between C++11 and what BOOST provides.
*
Vector &dst) const
{
parallel::transform (dst.begin(), dst.end(),
- std_cxx1x::bind (&SparseMatrix::vmult_one_row,
+ std_cxx11::bind (&SparseMatrix::vmult_one_row,
this,
- std_cxx1x::cref(src),
- std_cxx1x::ref(dst),
- std_cxx1x::_1),
+ std_cxx11::cref(src),
+ std_cxx11::ref(dst),
+ std_cxx11::_1),
200);
}
* @endcode
* Note how we use <a
- * href="http://www.boost.org/doc/libs/1_37_0/libs/bind/bind.html">std_cxx1x::bind</a>
+ * href="http://www.boost.org/doc/libs/1_37_0/libs/bind/bind.html">std_cxx11::bind</a>
* to <i>bind</i> certain arguments to the <code>vmult_one_row</code>
* function, leaving one argument open and thus allowing the
* parallel::transform function to consider the passed function argument as
* unary. Also note that we need to make the source and destination vectors as
- * (const) references to prevent std_cxx1x::bind from passing them by value
+ * (const) references to prevent std_cxx11::bind from passing them by value
* (implying a copy for <code>src</code> and writing the result into a
* temporary copy of <code>dst</code>, neither of which is what we desired).
* Finally, notice the grainsize of a minimum of 200 rows of a matrix that
Vector &dst) const
{
parallel::apply_to_subranges (0, n_rows(),
- std_cxx1x::bind (vmult_on_subrange,
+ std_cxx11::bind (vmult_on_subrange,
this,
- std_cxx1x::_1, std_cxx1x::_2,
- std_cxx1x::cref(src),
- std_cxx1x::ref(dst)),
+ std_cxx11::_1, std_cxx11::_2,
+ std_cxx11::cref(src),
+ std_cxx11::ref(dst)),
200);
}
* @endcode
return
std::sqrt
(parallel::accumulate_from_subranges (0, n_rows(),
- std_cxx1x::bind (mat_norm_sqr_on_subrange,
+ std_cxx11::bind (mat_norm_sqr_on_subrange,
this,
- std_cxx1x::_1, std_cxx1x::_2,
- std_cxx1x::cref(x)),
+ std_cxx11::_1, std_cxx11::_2,
+ std_cxx11::cref(x)),
200));
}
* @endcode
// ...is the same as:
WorkStream::run (dof_handler.begin_active(),
dof_handler.end(),
- std_cxx1x::bind(&MyClass<dim>::assemble_on_one_cell,
+ std_cxx11::bind(&MyClass<dim>::assemble_on_one_cell,
*this,
- std_cxx1x::_1,
- std_cxx1x::_2,
- std_cxx1x::_3),
- std_cxx1x::bind(&MyClass<dim>::copy_local_to_global,
+ std_cxx11::_1,
+ std_cxx11::_2,
+ std_cxx11::_3),
+ std_cxx11::bind(&MyClass<dim>::copy_local_to_global,
*this,
- std_cxx1x::_1),
+ std_cxx11::_1),
per_task_data);
* @endcode
- * Note how <code>std_cxx1x::bind</code> produces a function object that takes three
+ * Note how <code>std_cxx11::bind</code> produces a function object that takes three
* arguments by binding the member function to the <code>*this</code>
- * object. <code>std_cxx1x::_1, std_cxx1x::_2</code> and <code>std_cxx1x::_3</code> are placeholders for the first,
+ * object. <code>std_cxx11::_1, std_cxx11::_2</code> and <code>std_cxx11::_3</code> are placeholders for the first,
* second and third argument that can be specified later on. In other words, for
* example if <code>p</code> is the result of the first call to
- * <code>std_cxx1x::bind</code>, then the call <code>p(cell, scratch_data,
+ * <code>std_cxx11::bind</code>, then the call <code>p(cell, scratch_data,
* per_task_data)</code> will result in executing
* <code>this-@>assemble_on_one_cell (cell, scratch_data, per_task_data)</code>,
- * i.e. <code>std_cxx1x::bind</code> has bound the object to the function pointer
+ * i.e. <code>std_cxx11::bind</code> has bound the object to the function pointer
* but left the three arguments open for later.
*
* Similarly, let us assume that <code>MyClass::assemble_on_one_cell</code>
* @code
WorkStream::run (dof_handler.begin_active(),
dof_handler.end(),
- std_cxx1x::bind(&MyClass<dim>::assemble_on_one_cell,
+ std_cxx11::bind(&MyClass<dim>::assemble_on_one_cell,
*this,
current_solution,
- std_cxx1x::_1,
- std_cxx1x::_2,
- std_cxx1x::_3,
+ std_cxx11::_1,
+ std_cxx11::_2,
+ std_cxx11::_3,
previous_time+time_step),
- std_cxx1x::bind(&MyClass<dim>::copy_local_to_global,
+ std_cxx11::bind(&MyClass<dim>::copy_local_to_global,
*this,
- std_cxx1x::_1),
+ std_cxx11::_1),
per_task_data);
* @endcode
* Here, we bind the object, the linearization point argument, and the
* current time argument to the function before we hand it off to
* WorkStream::run(). WorkStream::run() will then simply call the
* function with the cell and scratch and per task objects which will be filled
- * in at the positions indicated by <code>std_cxx1x::_1, std_cxx1x::_2</code>
- * and <code>std_cxx1x::_3</code>.
+ * in at the positions indicated by <code>std_cxx11::_1, std_cxx11::_2</code>
+ * and <code>std_cxx11::_3</code>.
*
* There are refinements to the WorkStream::run function shown above.
* For example, one may realize that the basic idea above can only scale
*
* @ingroup CPP11
*/
-namespace std_cxx1x
+namespace std_cxx11
{
}
<ol>
+ <li> Changed: Namespace std_cxx1x has been renamed to namespace
+ std_cxx11 to match the fact that the corresponding C++ standard
+ was approved back in 2011. The old namespace name was retained for
+ backward compatibility but is now deprecated.
+ <br>
+ (Wolfgang Bangerth, 2014/09/01)
+ </li>
+
<li> New: Most of the operations done on Vector (like add, sadd, etc.)
are now vectorized (SIMD) using OpenMP 4.0
<br>
WorkStream::run(dof_handler.begin_active(),
dof_handler.end(),
- std_cxx1x::bind(&Solver<dim>::local_assemble_matrix,
+ std_cxx11::bind(&Solver<dim>::local_assemble_matrix,
this,
- std_cxx1x::_1,
- std_cxx1x::_2,
- std_cxx1x::_3),
- std_cxx1x::bind(&Solver<dim>::copy_local_to_global,
+ std_cxx11::_1,
+ std_cxx11::_2,
+ std_cxx11::_3),
+ std_cxx11::bind(&Solver<dim>::copy_local_to_global,
this,
- std_cxx1x::_1,
- std_cxx1x::ref(linear_system)),
+ std_cxx11::_1,
+ std_cxx11::ref(linear_system)),
AssemblyScratchData(*fe, *quadrature),
AssemblyCopyData());
linear_system.hanging_node_constraints.condense (linear_system.matrix);
- // The syntax above using <code>std_cxx1x::bind</code> requires
+ // The syntax above using <code>std_cxx11::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_cxx1x::bind</code>) which takes a pointer to a
+ // <code>std_cxx11::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_cxx1x::_1</code>, <code>std_cxx1x::_2</code>, etc.,
+ // <code>std_cxx11::_1</code>, <code>std_cxx11::_2</code>, etc.,
// mean. (These arguments are called <i>placeholders</i>.) The
- // idea of using <code>std_cxx1x::bind</code> in the first of
+ // idea of using <code>std_cxx11::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_cxx1x::function@<void f(double,double)@></code> and
- // initializing <code>p=std_cxx1x::bind(&f, std_cxx1x::_2,
- // std_cxx1x::_1)</code> then calling <code>p(1,2)</code> will
+ // <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
// result in calling <code>f(2,1)</code>.
//
// @note Once deal.II can rely on every compiler being able to
= &DoFTools::make_hanging_node_constraints;
// Start a side task then continue on the main thread
- Threads::Task<> side_task(std_cxx1x::bind(mhnc_p,std_cxx1x::cref(dof_handler),
- std_cxx1x::ref(hanging_node_constraints)));
+ Threads::Task<> side_task(std_cxx11::bind(mhnc_p,std_cxx11::cref(dof_handler),
+ std_cxx11::ref(hanging_node_constraints)));
sparsity_pattern.reinit (dof_handler.n_dofs(),
dof_handler.n_dofs(),
WorkStream::run(dof_handler.begin_active(),
dof_handler.end(),
- std_cxx1x::bind(&Solver<dim>::local_assemble_matrix,
+ std_cxx11::bind(&Solver<dim>::local_assemble_matrix,
this,
- std_cxx1x::_1,
- std_cxx1x::_2,
- std_cxx1x::_3),
- std_cxx1x::bind(&Solver<dim>::copy_local_to_global,
+ std_cxx11::_1,
+ std_cxx11::_2,
+ std_cxx11::_3),
+ std_cxx11::bind(&Solver<dim>::copy_local_to_global,
this,
- std_cxx1x::_1,
- std_cxx1x::ref(linear_system)),
+ std_cxx11::_1,
+ std_cxx11::ref(linear_system)),
AssemblyScratchData(*fe, *quadrature),
AssemblyCopyData());
// in step-9:
void estimate_error (Vector<float> &error_indicators) const;
- void estimate_on_one_cell (const SynchronousIterators<std_cxx1x::tuple<
+ void estimate_on_one_cell (const SynchronousIterators<std_cxx11::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_cxx1x::tuple<
+ integrate_over_cell (const SynchronousIterators<std_cxx11::tuple<
active_cell_iterator,Vector<float>::iterator> > &cell_and_error,
const Vector<double> &primal_solution,
const Vector<double> &dual_weights,
.get_tria().n_active_cells());
typedef
- std_cxx1
x::tuple<active_cell_iterator,Vector<float>::iterator>
+ std_cxx1
1::tuple<active_cell_iterator,Vector<float>::iterator>
IteratorTuple;
SynchronousIterators<IteratorTuple>
WorkStream::run(cell_and_error_begin,
cell_and_error_end,
- std_cxx1x::bind(&WeightedResidual<dim>::estimate_on_one_cell,
+ std_cxx11::bind(&WeightedResidual<dim>::estimate_on_one_cell,
this,
- std_cxx1x::_1,
- std_cxx1x::_2,
- std_cxx1x::_3,
- std_cxx1x::ref(face_integrals)),
- std_cxx1x::function<void (const WeightedResidualCopyData &)>(),
+ std_cxx11::_1,
+ std_cxx11::_2,
+ std_cxx11::_3,
+ std_cxx11::ref(face_integrals)),
+ std_cxx11::function<void (const WeightedResidualCopyData &)>(),
WeightedResidualScratchData (primal_solver,
dual_solver,
primal_solution,
template <int dim>
void
WeightedResidual<dim>::
- estimate_on_one_cell (const SynchronousIterators<std_cxx1x::tuple<
+ estimate_on_one_cell (const SynchronousIterators<std_cxx11::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_cxx1x::get<0>(cell_and_error.iterators);
+ active_cell_iterator cell = std_cxx11::get<0>(cell_and_error.iterators);
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_cxx1x::tuple<
+ integrate_over_cell (const SynchronousIterators<std_cxx11::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_cxx1x::get<0>(cell_and_error.iterators));
+ cell_data.fe_values.reinit (std_cxx11::get<0>(cell_and_error.iterators));
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_cxx1x::get<1>(cell_and_error.iterators)) += sum;
+ *(std_cxx11::get<1>(cell_and_error.iterators)) += sum;
}
// 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_cxx1x::shared_ptr<typename InnerPreconditioner<dim>::type> A_preconditioner;
+ std_cxx11::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_cxx1x::shared_ptr<typename InnerPreconditioner<dim>::type>(new typename InnerPreconditioner<dim>::type());
+ = std_cxx11::shared_ptr<typename InnerPreconditioner<dim>::type>(new typename InnerPreconditioner<dim>::type());
A_preconditioner->initialize (system_matrix.block(0,0),
typename InnerPreconditioner<dim>::type::AdditionalData());
double old_time_step;
unsigned int timestep_number;
- std_cxx1x::shared_ptr<TrilinosWrappers::PreconditionAMG> Amg_preconditioner;
- std_cxx1x::shared_ptr<TrilinosWrappers::PreconditionIC> Mp_preconditioner;
+ std_cxx11::shared_ptr<TrilinosWrappers::PreconditionAMG> Amg_preconditioner;
+ std_cxx11::shared_ptr<TrilinosWrappers::PreconditionIC> Mp_preconditioner;
bool rebuild_stokes_matrix;
bool rebuild_temperature_matrices;
assemble_stokes_preconditioner ();
- Amg_preconditioner = std_cxx1x::shared_ptr<TrilinosWrappers::PreconditionAMG>
+ Amg_preconditioner = std_cxx11::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_cxx1x::shared_ptr</code>
+ // wrap the preconditioners into a <code>std_cxx11::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_cxx1x::shared_ptr<TrilinosWrappers::PreconditionIC>
+ Mp_preconditioner = std_cxx11::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_cxx1x::shared_ptr<TrilinosWrappers::PreconditionAMG> Amg_preconditioner;
- std_cxx1x::shared_ptr<TrilinosWrappers::PreconditionJacobi> Mp_preconditioner;
- std_cxx1x::shared_ptr<TrilinosWrappers::PreconditionJacobi> T_preconditioner;
+ std_cxx11::shared_ptr<TrilinosWrappers::PreconditionAMG> Amg_preconditioner;
+ std_cxx11::shared_ptr<TrilinosWrappers::PreconditionJacobi> Mp_preconditioner;
+ std_cxx11::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_cxx1x::bind</code> to
+ // Note how we use the construct <code>std_cxx11::bind</code> to
// create a function object that satisfies this requirement. It uses
- // placeholders <code>std_cxx1x::_1, std_cxx1x::_2,
- // std_cxx1x::_3</code> for the local assembly function that specify
+ // placeholders <code>std_cxx11::_1, std_cxx11::_2,
+ // std_cxx11::_3</code> for the local assembly function that specify
// cell, scratch data, and copy data, as well as the placeholder
- // <code>std_cxx1x::_1</code> for the copy function that expects the
+ // <code>std_cxx11::_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_cxx1x::bind (&BoussinesqFlowProblem<dim>::
+ std_cxx11::bind (&BoussinesqFlowProblem<dim>::
local_assemble_stokes_preconditioner,
this,
- std_cxx1x::_1,
- std_cxx1x::_2,
- std_cxx1x::_3),
- std_cxx1x::bind (&BoussinesqFlowProblem<dim>::
+ std_cxx11::_1,
+ std_cxx11::_2,
+ std_cxx11::_3),
+ std_cxx11::bind (&BoussinesqFlowProblem<dim>::
copy_local_to_global_stokes_preconditioner,
this,
- std_cxx1x::_1),
+ std_cxx11::_1),
Assembly::Scratch::
StokesPreconditioner<dim> (stokes_fe, quadrature_formula,
mapping,
stokes_dof_handler.begin_active()),
CellFilter (IteratorFilters::LocallyOwnedCell(),
stokes_dof_handler.end()),
- std_cxx1x::bind (&BoussinesqFlowProblem<dim>::
+ std_cxx11::bind (&BoussinesqFlowProblem<dim>::
local_assemble_stokes_system,
this,
- std_cxx1x::_1,
- std_cxx1x::_2,
- std_cxx1x::_3),
- std_cxx1x::bind (&BoussinesqFlowProblem<dim>::
+ std_cxx11::_1,
+ std_cxx11::_2,
+ std_cxx11::_3),
+ std_cxx11::bind (&BoussinesqFlowProblem<dim>::
copy_local_to_global_stokes_system,
this,
- std_cxx1x::_1),
+ std_cxx11::_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_cxx1x::bind (&BoussinesqFlowProblem<dim>::
+ std_cxx11::bind (&BoussinesqFlowProblem<dim>::
local_assemble_temperature_matrix,
this,
- std_cxx1x::_1,
- std_cxx1x::_2,
- std_cxx1x::_3),
- std_cxx1x::bind (&BoussinesqFlowProblem<dim>::
+ std_cxx11::_1,
+ std_cxx11::_2,
+ std_cxx11::_3),
+ std_cxx11::bind (&BoussinesqFlowProblem<dim>::
copy_local_to_global_temperature_matrix,
this,
- std_cxx1x::_1),
+ std_cxx11::_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_cxx1x::bind (&BoussinesqFlowProblem<dim>::
+ std_cxx11::bind (&BoussinesqFlowProblem<dim>::
local_assemble_temperature_rhs,
this,
global_T_range,
maximal_velocity,
global_entropy_variation,
- std_cxx1x::_1,
- std_cxx1x::_2,
- std_cxx1x::_3),
- std_cxx1x::bind (&BoussinesqFlowProblem<dim>::
+ std_cxx11::_1,
+ std_cxx11::_2,
+ std_cxx11::_3),
+ std_cxx11::bind (&BoussinesqFlowProblem<dim>::
copy_local_to_global_temperature_rhs,
this,
- std_cxx1x::_1),
+ std_cxx11::_1),
Assembly::Scratch::
TemperatureRHS<dim> (temperature_fe, stokes_fe, mapping,
quadrature_formula),
Functions::ParsedFunction<dim> exact_solution;
unsigned int singular_quadrature_order;
- std_cxx1x::shared_ptr<Quadrature<dim-1> > quadrature;
+ std_cxx11::shared_ptr<Quadrature<dim-1> > quadrature;
SolverControl solver_control;
prm.enter_subsection("Quadrature rules");
{
quadrature =
- std_cxx1x::shared_ptr<Quadrature<dim-1> >
+ std_cxx11::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_cxx1x::tuple< typename DoFHandler<dim>::active_cell_iterator,
+ typedef std_cxx11::tuple< typename DoFHandler<dim>::active_cell_iterator,
typename DoFHandler<dim>::active_cell_iterator
> IteratorTuple;
InitGradScratchData &scratch,
InitGradPerTaskData &data)
{
- scratch.fe_val_vel.reinit (std_cxx1x::get<0> (SI.iterators));
- scratch.fe_val_pres.reinit (std_cxx1x::get<1> (SI.iterators));
+ scratch.fe_val_vel.reinit (std_cxx11::get<0> (SI.iterators));
+ scratch.fe_val_pres.reinit (std_cxx11::get<1> (SI.iterators));
- std_cxx1x::get<0> (SI.iterators)->get_dof_indices (data.vel_local_dof_indices);
- std_cxx1x::get<1> (SI.iterators)->get_dof_indices (data.pres_local_dof_indices);
+ std_cxx11::get<0> (SI.iterators)->get_dof_indices (data.vel_local_dof_indices);
+ std_cxx11::get<1> (SI.iterators)->get_dof_indices (data.pres_local_dof_indices);
data.local_grad = 0.;
for (unsigned int q=0; q<scratch.nqp; ++q)
// one shot at setting it; the same is true for the mesh refinement
// criterion):
const std::string base_mesh;
- const std_cxx1x::shared_ptr<const Function<dim> > obstacle;
+ const std_cxx11::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_cxx1x/shared_ptr.h>
+#include <deal.II/base/std_cxx11/shared_ptr.h>
#include <deal.II/lac/full_matrix.h>
#include <deal.II/lac/solver_gmres.h>
const double porosity;
const double AOS_threshold;
- std_cxx1x::shared_ptr<TrilinosWrappers::PreconditionIC> Amg_preconditioner;
- std_cxx1x::shared_ptr<TrilinosWrappers::PreconditionIC> Mp_preconditioner;
+ std_cxx11::shared_ptr<TrilinosWrappers::PreconditionIC> Amg_preconditioner;
+ std_cxx11::shared_ptr<TrilinosWrappers::PreconditionIC> Mp_preconditioner;
bool rebuild_saturation_matrix;
{
assemble_darcy_preconditioner ();
- Amg_preconditioner = std_cxx1x::shared_ptr<TrilinosWrappers::PreconditionIC>
+ Amg_preconditioner = std_cxx11::shared_ptr<TrilinosWrappers::PreconditionIC>
(new TrilinosWrappers::PreconditionIC());
Amg_preconditioner->initialize(darcy_preconditioner_matrix.block(0,0));
- Mp_preconditioner = std_cxx1x::shared_ptr<TrilinosWrappers::PreconditionIC>
+ Mp_preconditioner = std_cxx11::shared_ptr<TrilinosWrappers::PreconditionIC>
(new TrilinosWrappers::PreconditionIC());
Mp_preconditioner->initialize(darcy_preconditioner_matrix.block(1,1));
WorkStream::run(dof_handler_u_post.begin_active(),
dof_handler_u_post.end(),
- std_cxx1x::bind (&HDG<dim>::postprocess_one_cell,
- std_cxx1x::ref(*this),
- std_cxx1x::_1, std_cxx1x::_2, std_cxx1x::_3),
- std_cxx1x::function<void(const unsigned int &)>(),
+ 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 &)>(),
scratch,
0U);
}
for (unsigned int i=0; i<n_time_steps; ++i)
{
time = explicit_runge_kutta.evolve_one_time_step(
- std_cxx1x::bind(&Diffusion::evaluate_diffusion,this,std_cxx1x::_1,std_cxx1x::_2),
+ std_cxx11::bind(&Diffusion::evaluate_diffusion,this,std_cxx11::_1,std_cxx11::_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_cxx1x::bind(&Diffusion::evaluate_diffusion,this,std_cxx1x::_1,std_cxx1x::_2),
- std_cxx1x::bind(&Diffusion::id_minus_tau_J_inverse,this,std_cxx1x::_1,std_cxx1x::_2,
- std_cxx1x::_3),
+ 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),
time,time_step,solution);
if ((i+1)%10==0)
time_step = final_time-time;
time = embedded_explicit_runge_kutta.evolve_one_time_step(
- std_cxx1x::bind(&Diffusion::evaluate_diffusion,this,std_cxx1x::_1,std_cxx1x::_2),
+ std_cxx11::bind(&Diffusion::evaluate_diffusion,this,std_cxx11::_1,std_cxx11::_2),
time,time_step,solution);
if ((n_steps+1)%10==0)
#include <deal.II/grid/grid_generator.h>
#include <deal.II/grid/grid_out.h>
-#include <deal.II/base/std_cxx1x/array.h>
+#include <deal.II/base/std_cxx11/array.h>
#include <fstream>
get_new_point_on_quad (const typename Triangulation<dim>::quad_iterator &quad) const;
private:
- std_cxx1x::array<double,dim> pull_back (const Point<dim> &p) const;
- Point<dim> push_forward (const std_cxx1x::array<double,dim> &preimage) const;
+ std_cxx11::array<double,dim> pull_back (const Point<dim> &p) const;
+ Point<dim> push_forward (const std_cxx11::array<double,dim> &preimage) const;
template <int N>
- static std_cxx1x::array<double,dim> average (const std_cxx1x::array<double,dim> (&array)[N]);
+ static std_cxx11::array<double,dim> average (const std_cxx11::array<double,dim> (&array)[N]);
const Point<dim> center;
};
template <>
-std_cxx1x::array<double,2>
+std_cxx11::array<double,2>
SphereGeometry<2>::pull_back (const Point<2> &p) const
{
const Point<2> relative_point = p - center;
const double r = relative_point.norm();
const double phi = std::atan2 (relative_point[1], relative_point[0]);
- std_cxx1x::array<double,2> result;
+ std_cxx11::array<double,2> result;
result[0] = r;
result[1] = phi;
template <>
Point<2>
-SphereGeometry<2>::push_forward (const std_cxx1x::array<double,2> &preimage) const
+SphereGeometry<2>::push_forward (const std_cxx11::array<double,2> &preimage) const
{
const Point<2> relative_point = preimage[0] * Point<2>(std::cos(preimage[1]), std::sin(preimage[1]));
template <>
-std_cxx1x::array<double,3>
+std_cxx11::array<double,3>
SphereGeometry<3>::pull_back (const Point<3> &p) const
{
const Point<3> relative_point = p - center;
const double theta = std::atan2 (relative_point[2], std::sqrt (relative_point[0]*relative_point[0] +
relative_point[1]*relative_point[1]));
- std_cxx1x::array<double,3> result;
+ std_cxx11::array<double,3> result;
result[0] = r;
result[1] = phi;
result[2] = theta;
template <>
Point<3>
-SphereGeometry<3>::push_forward (const std_cxx1x::array<double,3> &preimage) const
+SphereGeometry<3>::push_forward (const std_cxx11::array<double,3> &preimage) const
{
const Point<3> relative_point = (preimage[0] *
Point<3>(std::cos(preimage[1]),
template <>
template <int N>
-std_cxx1x::array<double,2>
-SphereGeometry<2>::average (const std_cxx1x::array<double,2> (&array)[N])
+std_cxx11::array<double,2>
+SphereGeometry<2>::average (const std_cxx11::array<double,2> (&array)[N])
{
- std_cxx1x::array<double,2> result;
+ std_cxx11::array<double,2> result;
// average the radii first. this is uncritical
{
template <>
template <int N>
-std_cxx1x::array<double,3>
-SphereGeometry<3>::average (const std_cxx1x::array<double,3> (&array)[N])
+std_cxx11::array<double,3>
+SphereGeometry<3>::average (const std_cxx11::array<double,3> (&array)[N])
{
- std_cxx1x::array<double,3> result;
+ std_cxx11::array<double,3> result;
// average the radii first. this is uncritical
{
SphereGeometry<dim>::
get_new_point_on_quad (const typename Triangulation<dim>::quad_iterator &quad) const
{
- std_cxx1x::array<double,dim> preimages[4] = { pull_back (quad->vertex(0)),
+ std_cxx11::array<double,dim> preimages[4] = { pull_back (quad->vertex(0)),
pull_back (quad->vertex(1)),
pull_back (quad->vertex(2)),
pull_back (quad->vertex(3))
/* ---------------------------------------------------------------------
* $Id$
*
- * Copyright (C) 2000 - 2013 by the deal.II authors
+ * Copyright (C) 2000 - 2014 by the deal.II authors
*
* This file is part of the deal.II library.
*
template <int dim>
static
- void estimate_cell (const SynchronousIterators<std_cxx1x::tuple<typename DoFHandler<dim>::active_cell_iterator,
+ void estimate_cell (const SynchronousIterators<std_cxx11::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_tria().n_active_cells()));
- typedef std_cxx1x::tuple<typename DoFHandler<dim>::active_cell_iterator,Vector<float>::iterator>
+ typedef std_cxx11::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_cxx1x::function<void (const EstimateCopyData &)> (),
+ std_cxx11::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_cxx1x::function<void (const SynchronousIterators<IteratorTuple> &,
+ // std_cxx11::function<void (const SynchronousIterators<IteratorTuple> &,
// EstimateScratchData<dim> &,
// EstimateCopyData &)>
- // (std_cxx1x::bind (&GradientEstimation::template estimate_cell<dim>,
- // std_cxx1x::_1,
- // std_cxx1x::_2))
+ // (std_cxx11::bind (&GradientEstimation::template estimate_cell<dim>,
+ // std_cxx11::_1,
+ // std_cxx11::_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_cxx1x::tuple<typename DoFHandler<dim>::active_cell_iterator,
+ GradientEstimation::estimate_cell (const SynchronousIterators<std_cxx11::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_cxx1x::get<0>(cell.iterators));
+ typename DoFHandler<dim>::active_cell_iterator cell_it(std_cxx11::get<0>(cell.iterators));
// 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_cxx1x::get<0>(cell.iterators)->at_boundary(face_no))
+ if (! std_cxx11::get<0>(cell.iterators)->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_cxx1x::get<0>(cell.iterators)->face(face_no);
+ face = std_cxx11::get<0>(cell.iterators)->face(face_no);
const typename DoFHandler<dim>::cell_iterator
- neighbor = std_cxx1x::get<0>(cell.iterators)->neighbor(face_no);
+ neighbor = std_cxx11::get<0>(cell.iterators)->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_cxx1x::get<0>(cell.iterators),ExcInternalError());
+ ==std_cxx11::get<0>(cell.iterators),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_cxx1x::get<0>(cell.iterators)->neighbor_child_on_subface(face_no,subface_no));
+ std_cxx11::get<0>(cell.iterators)->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_cxx1x::get<1>(cell.iterators)) = (std::pow(std_cxx1x::get<0>(cell.iterators)->diameter(),
+ *(std_cxx11::get<1>(cell.iterators)) = (std::pow(std_cxx11::get<0>(cell.iterators)->diameter(),
1+1.0*dim/2) *
std::sqrt(gradient.square()));
#define __deal2__aligned_vector_h
#include <deal.II/base/config.h>
-#include <deal.II/base/std_cxx1x/type_traits.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/parallel.h>
// (void*) to silence compiler warning for virtual classes (they will
// never arrive here because they are non-trivial).
- if (std_cxx1x::is_trivial<T>::value == true)
+ if (std_cxx11::is_trivial<T>::value == true)
std::memcpy ((void *)(destination_+begin), source_+begin,
(end-begin)*sizeof(T));
else if (copy_only_ == 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_cxx1x::is_trivial<T>::value == true &&
+ if (std_cxx11::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_cxx1x::is_trivial<T>::value == true && trivial_element)
+ if (std_cxx11::is_trivial<T>::value == true && trivial_element)
std::memset ((void *)(destination_+begin), 0, (end-begin)*sizeof(T));
else
// initialize memory and set
const T &init)
{
const size_type old_size = size();
- if (std_cxx1x::is_trivial<T>::value == false && size_in < old_size)
+ if (std_cxx11::is_trivial<T>::value == false && size_in < old_size)
{
// call destructor on fields that are released
while (_end_data != _data+size_in)
{
if (_data != 0)
{
- if (std_cxx1x::is_trivial<T>::value == false)
+ if (std_cxx11::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_cxx1x::is_trivial<T>::value == false)
+ if (std_cxx11::is_trivial<T>::value == false)
new (_end_data) T;
*_end_data++ = in_data;
}
reserve (old_size + (end-begin));
for ( ; begin != end; ++begin, ++_end_data)
{
- if (std_cxx1x::is_trivial<T>::value == false)
+ if (std_cxx11::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_cxx1x/tuple.h>
+#include <deal.II/base/std_cxx11/tuple.h>
#include <vector>
#include <string>
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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const VtkFlags &flags,
std::ostream &out);
template <int spacedim>
void write_svg (const std::vector<Patch<2,spacedim> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
DataOutFilter &filtered_data);
/**
* collection of scalar fields.
*/
virtual
- std::vector<std_cxx1x::tuple<unsigned int, unsigned int, std::string> >
+ std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> >
get_vector_data_ranges () const;
/**
* collection of scalar fields.
*/
virtual
- std::vector<std_cxx1x::tuple<unsigned int, unsigned int, std::string> >
+ std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> >
+ std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> >
vector_data_ranges;
};
#include <deal.II/base/subscriptor.h>
#include <deal.II/base/tensor.h>
#include <deal.II/base/point.h>
-#include <deal.II/base/std_cxx1x/function.h>
+#include <deal.II/base/std_cxx11/function.h>
#include <vector>
* or we could write it like so:
* @code
* ScalarFunctionFromFunctionObject<dim, Number>
- * my_distance_object (std_cxx1x::bind (&Point<dim, Number>::distance,
+ * my_distance_object (std_cxx11::bind (&Point<dim, Number>::distance,
* q,
- * std_cxx1x::_1));
+ * std_cxx11::_1));
* @endcode
* The savings in work to write this are apparent.
*
* Given a function object that takes a Point and returns a Number value,
* convert this into an object that matches the Function<dim, Number> interface.
*/
- ScalarFunctionFromFunctionObject (const std_cxx1x::function<Number (const Point<dim, Number> &)> &function_object);
+ ScalarFunctionFromFunctionObject (const std_cxx11::function<Number (const Point<dim, Number> &)> &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_cxx1x::function<Number (const Point<dim, Number> &)> function_object;
+ const std_cxx11::function<Number (const Point<dim, Number> &)> function_object;
};
* @param selected_component The single component that should be
* filled by the first argument.
**/
- VectorFunctionFromScalarFunctionObject (const std_cxx1x::function<Number (const Point<dim, Number> &)> &function_object,
+ VectorFunctionFromScalarFunctionObject (const std_cxx11::function<Number (const Point<dim, Number> &)> &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_cxx1x::function<Number (const Point<dim, Number> &)> function_object;
+ const std_cxx11::function<Number (const Point<dim, Number> &)> function_object;
/**
* The vector component whose value is to be filled by the given scalar
// ---------------------------------------------------------------------
// $Id$
//
-// Copyright (C) 1999 - 2013 by the deal.II authors
+// Copyright (C) 1999 - 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/base/point.h>
#include <deal.II/base/table.h>
-#include <deal.II/base/std_cxx1x/array.h>
+#include <deal.II/base/std_cxx11/array.h>
DEAL_II_NAMESPACE_OPEN
* converting other data types into a table where you specify this
* argument.
*/
- InterpolatedTensorProductGridData (const std_cxx1x::array<std::vector<double>,dim> &coordinate_values,
+ InterpolatedTensorProductGridData (const std_cxx11::array<std::vector<double>,dim> &coordinate_values,
const Table<dim,double> &data_values);
/**
/**
* The set of coordinate values in each of the coordinate directions.
*/
- const std_cxx1x::array<std::vector<double>,dim> coordinate_values;
+ const std_cxx11::array<std::vector<double>,dim> coordinate_values;
/**
* The data that is to be interpolated.
* converting other data types into a table where you specify this
* argument.
*/
- InterpolatedUniformGridData (const std_cxx1x::array<std::pair<double,double>,dim> &interval_endpoints,
- const std_cxx1x::array<unsigned int,dim> &n_subintervals,
+ InterpolatedUniformGridData (const std_cxx11::array<std::pair<double,double>,dim> &interval_endpoints,
+ const std_cxx11::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_cxx1x::array<std::pair<double,double>,dim> interval_endpoints;
+ const std_cxx11::array<std::pair<double,double>,dim> interval_endpoints;
/**
* The number of subintervals in each of the coordinate directions.
*/
- const std_cxx1x::array<unsigned int,dim> n_subintervals;
+ const std_cxx11::array<unsigned int,dim> n_subintervals;
/**
* The data that is to be interpolated.
#include <deal.II/base/config.h>
#include <deal.II/base/thread_management.h>
-#include <deal.II/base/std_cxx1x/function.h>
+#include <deal.II/base/std_cxx11/function.h>
#include <deal.II/dofs/dof_handler.h>
#include <boost/unordered_map.hpp>
#include <boost/unordered_set.hpp>
std::vector<std::vector<Iterator> >
create_partitioning(const Iterator &begin,
const typename identity<Iterator>::type &end,
- const std_cxx1x::function<std::vector<types::global_dof_index> (const Iterator &)> &get_conflict_indices)
+ const std_cxx11::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_cxx1x::function<std::vector<types::global_dof_index> (const Iterator &)> &get_conflict_indices,
+ const std_cxx11::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_cxx1x::function<std::vector<types::global_dof_index> (const typename identity<Iterator>::type &)> &get_conflict_indices)
+ const std_cxx11::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_cxx1x/shared_ptr.h>
+#include <deal.II/base/std_cxx11/shared_ptr.h>
#include <deal.II/base/thread_local_storage.h>
#include <string>
* We use tbb's thread local storage facility to generate a stringstream
* for every thread that sends log messages.
*/
- Threads::ThreadLocalStorage<std_cxx1x::shared_ptr<std::ostringstream> > outstreams;
+ Threads::ThreadLocalStorage<std_cxx11::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_cxx1x/shared_ptr.h>
+#include <deal.II/base/std_cxx11/shared_ptr.h>
#include <string>
#include <complex>
*/
template <typename T>
inline
- std::size_t memory_consumption (const std_cxx1x::shared_ptr<T> &);
+ std::size_t memory_consumption (const std_cxx11::shared_ptr<T> &);
}
template <typename T>
inline
std::size_t
- memory_consumption (const std_cxx1x::shared_ptr<T> &)
+ memory_consumption (const std_cxx11::shared_ptr<T> &)
{
- return sizeof(std_cxx1x::shared_ptr<T>);
+ return sizeof(std_cxx11::shared_ptr<T>);
}
#include <deal.II/base/subscriptor.h>
#include <vector>
-#include <deal.II/base/std_cxx1x/shared_ptr.h>
+#include <deal.II/base/std_cxx11/shared_ptr.h>
DEAL_II_NAMESPACE_OPEN
/**
* Array of the objects to be held.
*/
- std::vector<std_cxx1x::shared_ptr<Object> > objects;
+ std::vector<std_cxx11::shared_ptr<Object> > objects;
};
minlevel = new_minlevel;
for (unsigned int i=0; i<new_maxlevel-new_minlevel+1; ++i)
- objects.push_back(std_cxx1x::shared_ptr<Object> (new Object));
+ objects.push_back(std_cxx11::shared_ptr<Object> (new Object));
}
MGLevelObject<Object> &
MGLevelObject<Object>::operator = (const double d)
{
- typename std::vector<std_cxx1x::shared_ptr<Object> >::iterator v;
+ typename std::vector<std_cxx11::shared_ptr<Object> >::iterator v;
for (v = objects.begin(); v != objects.end(); ++v)
**v=d;
return *this;
void
MGLevelObject<Object>::clear ()
{
- typename std::vector<std_cxx1x::shared_ptr<Object> >::iterator v;
+ typename std::vector<std_cxx11::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_cxx1x::shared_ptr<Object> >::const_iterator Iter;
+ typedef typename std::vector<std_cxx11::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/template_constraints.h>
#include <deal.II/base/synchronous_iterator.h>
-#include <deal.II/base/std_cxx1x/tuple.h>
-#include <deal.II/base/std_cxx1x/bind.h>
-#include <deal.II/base/std_cxx1x/function.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 <cstddef>
static
void
apply (const F &f,
- const std_cxx1x::tuple<I1,I2> &p)
+ const std_cxx11::tuple<I1,I2> &p)
{
- *std_cxx1x::get<1>(p) = f (*std_cxx1x::get<0>(p));
+ *std_cxx11::get<1>(p) = f (*std_cxx11::get<0>(p));
}
/**
static
void
apply (const F &f,
- const std_cxx1x::tuple<I1,I2,I3> &p)
+ const std_cxx11::tuple<I1,I2,I3> &p)
{
- *std_cxx1x::get<2>(p) = f (*std_cxx1x::get<0>(p),
- *std_cxx1x::get<1>(p));
+ *std_cxx11::get<2>(p) = f (*std_cxx11::get<0>(p),
+ *std_cxx11::get<1>(p));
}
/**
static
void
apply (const F &f,
- const std_cxx1x::tuple<I1,I2,I3,I4> &p)
+ const std_cxx11::tuple<I1,I2,I3,I4> &p)
{
- *std_cxx1x::get<3>(p) = f (*std_cxx1x::get<0>(p),
- *std_cxx1x::get<1>(p),
- *std_cxx1x::get<2>(p));
+ *std_cxx11::get<3>(p) = f (*std_cxx11::get<0>(p),
+ *std_cxx11::get<1>(p),
+ *std_cxx11::get<2>(p));
}
};
for (OutputIterator in = begin_in; in != end_in;)
*out++ = predicate (*in++);
#else
- typedef std_cxx1x::tuple<InputIterator,OutputIterator> Iterators;
+ typedef std_cxx11::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_cxx1x::tuple<InputIterator1,InputIterator2,OutputIterator>
+ std_cxx11::tuple<InputIterator1,InputIterator2,OutputIterator>
Iterators;
typedef SynchronousIterators<Iterators> SyncIterators;
Iterators x_begin (begin_in1, in2, out);
*out++ = predicate (*in1++, *in2++, *in3++);
#else
typedef
- std_cxx1x::tuple<InputIterator1,InputIterator2,InputIterator3,OutputIterator>
+ std_cxx11::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_cxx1x::bind (&mat_vec_on_subranges,
- * std_cxx1x::_1, std_cxx1x::_2,
- * std_cxx1x::cref(A),
- * std_cxx1x::cref(x),
- * std_cxx1x::ref(y)),
+ * 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)),
* 50);
* }
*
* @endcode
*
* Note how we use the
- * <code>std_cxx1x::bind</code> function to
+ * <code>std_cxx11::bind</code> function to
* convert
* <code>mat_vec_on_subranged</code> from a
* function that takes 5 arguments to one
* taking 2 by binding the remaining
* arguments (the modifiers
- * <code>std_cxx1x::ref</code> and
- * <code>std_cxx1x::cref</code> make sure
+ * <code>std_cxx11::ref</code> and
+ * <code>std_cxx11::cref</code> make sure
* that the enclosed variables are actually
* passed by reference and constant
* reference, rather than by value). The
#else
tbb::parallel_for (tbb::blocked_range<RangeType>
(begin, end, grainsize),
- std_cxx1x::bind (&internal::apply_to_subranges<RangeType,Function>,
- std_cxx1x::_1,
- std_cxx1x::cref(f)),
+ std_cxx11::bind (&internal::apply_to_subranges<RangeType,Function>,
+ std_cxx11::_1,
+ std_cxx11::cref(f)),
tbb::auto_partitioner());
#endif
}
* reduce the result of two calls
* into one number.
*/
- const std_cxx1x::function<ResultType (ResultType, ResultType)> reductor;
+ const std_cxx11::function<ResultType (ResultType, ResultType)> reductor;
};
#endif
}
* std::sqrt
* (parallel::accumulate_from_subranges<double>
* (0, A.n_rows(),
- * std_cxx1x::bind (&mat_norm_sqr_on_subranges,
- * std_cxx1x::_1, std_cxx1x::_2,
- * std_cxx1x::cref(A),
- * std_cxx1x::cref(x)),
+ * std_cxx11::bind (&mat_norm_sqr_on_subranges,
+ * std_cxx11::_1, std_cxx11::_2,
+ * std_cxx11::cref(A),
+ * std_cxx11::cref(x)),
* 50);
* }
*
#include <deal.II/base/config.h>
#include <deal.II/base/exceptions.h>
#include <deal.II/base/subscriptor.h>
-#include <deal.II/base/std_cxx1x/shared_ptr.h>
+#include <deal.II/base/std_cxx11/shared_ptr.h>
#include <boost/property_tree/ptree_fwd.hpp>
#include <boost/serialization/split_member.hpp>
* 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_cxx1x::shared_ptr<const Patterns::PatternBase> > patterns;
+ std::vector<std_cxx11::shared_ptr<const Patterns::PatternBase> > patterns;
/**
* Mangle a string so that it doesn't contain any special characters or
patterns.clear ();
for (unsigned int j=0; j<descriptions.size(); ++j)
- patterns.push_back (std_cxx1x::shared_ptr<const Patterns::PatternBase>(Patterns::pattern_factory(descriptions[j])));
+ patterns.push_back (std_cxx11::shared_ptr<const Patterns::PatternBase>(Patterns::pattern_factory(descriptions[j])));
}
#include <deal.II/base/exceptions.h>
#include <deal.II/base/subscriptor.h>
#include <deal.II/base/point.h>
-#include <deal.II/base/std_cxx1x/shared_ptr.h>
+#include <deal.II/base/std_cxx11/shared_ptr.h>
#include <vector>
/**
* Coefficients for the interval $[0,1]$.
*/
- static std::vector<std_cxx1x::shared_ptr<const std::vector<double> > > shifted_coefficients;
+ static std::vector<std_cxx11::shared_ptr<const std::vector<double> > > shifted_coefficients;
/**
* Vector with already computed
* free the memory of the vectors when
* the global destructor is called.
*/
- static std::vector<std_cxx1x::shared_ptr<const std::vector<double> > > recursive_coefficients;
+ static std::vector<std_cxx11::shared_ptr<const std::vector<double> > > recursive_coefficients;
/**
* Compute coefficients recursively.
* free the memory of the vectors when
* the global destructor is called.
*/
- static std::vector<std_cxx1x::shared_ptr<const std::vector<double> > > recursive_coefficients;
+ static std::vector<std_cxx11::shared_ptr<const std::vector<double> > > recursive_coefficients;
};
--- /dev/null
+// ---------------------------------------------------------------------
+// $Id$
+//
+// Copyright (C) 2009 - 2013 by the deal.II authors
+//
+// This file is part of the deal.II library.
+//
+// The deal.II library is free software; you can use it, redistribute
+// it, and/or modify it under the terms of the GNU Lesser General
+// Public License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+// The full text of the license can be found in the file LICENSE at
+// the top level of the deal.II distribution.
+//
+// ---------------------------------------------------------------------
+
+#ifndef __deal2__std_cxx11_array_h
+#define __deal2__std_cxx11_array_h
+
+
+#include <deal.II/base/config.h>
+
+#ifdef DEAL_II_WITH_CXX11
+
+# include <array>
+DEAL_II_NAMESPACE_OPEN
+namespace std_cxx11
+{
+ using std::array;
+}
+DEAL_II_NAMESPACE_CLOSE
+
+#else
+
+#include <boost/array.hpp>
+DEAL_II_NAMESPACE_OPEN
+namespace std_cxx11
+{
+ using boost::array;
+}
+DEAL_II_NAMESPACE_CLOSE
+
+#endif
+
+#endif
--- /dev/null
+// ---------------------------------------------------------------------
+// $Id$
+//
+// Copyright (C) 2009 - 2013 by the deal.II authors
+//
+// This file is part of the deal.II library.
+//
+// The deal.II library is free software; you can use it, redistribute
+// it, and/or modify it under the terms of the GNU Lesser General
+// Public License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+// The full text of the license can be found in the file LICENSE at
+// the top level of the deal.II distribution.
+//
+// ---------------------------------------------------------------------
+
+#ifndef __deal2__std_cxx11_bind_h
+#define __deal2__std_cxx11_bind_h
+
+
+#include <deal.II/base/config.h>
+
+#ifdef DEAL_II_WITH_CXX11
+
+# include <functional>
+
+DEAL_II_NAMESPACE_OPEN
+// in boost, the placeholders _1, _2, ... are in the global namespace. in
+// C++0x, they are in namespace std::placeholders, which makes them awkward to
+// use. import them into the deal.II::std_cxx11 namespace instead and do them
+// same below if we use boost instead.
+namespace std_cxx11
+{
+ using namespace std::placeholders;
+ using std::bind;
+ using std::ref;
+ using std::cref;
+ using std::reference_wrapper;
+}
+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;
+}
+DEAL_II_NAMESPACE_CLOSE
+
+#endif
+
+#endif
--- /dev/null
+// ---------------------------------------------------------------------
+// $Id$
+//
+// Copyright (C) 2009 - 2013 by the deal.II authors
+//
+// This file is part of the deal.II library.
+//
+// The deal.II library is free software; you can use it, redistribute
+// it, and/or modify it under the terms of the GNU Lesser General
+// Public License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+// The full text of the license can be found in the file LICENSE at
+// the top level of the deal.II distribution.
+//
+// ---------------------------------------------------------------------
+
+#ifndef __deal2__std_cxx11_condition_variable_h
+#define __deal2__std_cxx11_condition_variable_h
+
+
+#include <deal.II/base/config.h>
+
+#ifdef DEAL_II_WITH_CXX11
+
+# include <condition_variable>
+DEAL_II_NAMESPACE_OPEN
+namespace std_cxx11
+{
+ using std::condition_variable;
+ using std::unique_lock;
+ using std::adopt_lock;
+}
+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
+
+#endif
--- /dev/null
+// ---------------------------------------------------------------------
+// $Id$
+//
+// Copyright (C) 2009 - 2013 by the deal.II authors
+//
+// This file is part of the deal.II library.
+//
+// The deal.II library is free software; you can use it, redistribute
+// it, and/or modify it under the terms of the GNU Lesser General
+// Public License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+// The full text of the license can be found in the file LICENSE at
+// the top level of the deal.II distribution.
+//
+// ---------------------------------------------------------------------
+
+#ifndef __deal2__std_cxx11_function_h
+#define __deal2__std_cxx11_function_h
+
+
+#include <deal.II/base/config.h>
+
+#ifdef DEAL_II_WITH_CXX11
+
+# include <functional>
+DEAL_II_NAMESPACE_OPEN
+namespace std_cxx11
+{
+ using std::function;
+}
+DEAL_II_NAMESPACE_CLOSE
+
+#else
+
+#include <boost/function.hpp>
+DEAL_II_NAMESPACE_OPEN
+namespace std_cxx11
+{
+ using boost::function;
+}
+DEAL_II_NAMESPACE_CLOSE
+
+#endif
+
+#endif
--- /dev/null
+// ---------------------------------------------------------------------
+// $Id$
+//
+// Copyright (C) 2009 - 2013 by the deal.II authors
+//
+// This file is part of the deal.II library.
+//
+// The deal.II library is free software; you can use it, redistribute
+// it, and/or modify it under the terms of the GNU Lesser General
+// Public License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+// The full text of the license can be found in the file LICENSE at
+// the top level of the deal.II distribution.
+//
+// ---------------------------------------------------------------------
+
+#ifndef __deal2__std_cxx11_mutex_h
+#define __deal2__std_cxx11_mutex_h
+
+
+#include <deal.II/base/config.h>
+
+#ifdef DEAL_II_WITH_CXX11
+
+# include <mutex>
+DEAL_II_NAMESPACE_OPEN
+namespace std_cxx11
+{
+ using std::mutex;
+}
+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
+
+#endif
--- /dev/null
+// ---------------------------------------------------------------------
+// $Id$
+//
+// Copyright (C) 2009 - 2013 by the deal.II authors
+//
+// This file is part of the deal.II library.
+//
+// The deal.II library is free software; you can use it, redistribute
+// it, and/or modify it under the terms of the GNU Lesser General
+// Public License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+// The full text of the license can be found in the file LICENSE at
+// the top level of the deal.II distribution.
+//
+// ---------------------------------------------------------------------
+
+#ifndef __deal2__std_cxx11_shared_ptr_h
+#define __deal2__std_cxx11_shared_ptr_h
+
+
+#include <deal.II/base/config.h>
+
+#ifdef DEAL_II_WITH_CXX11
+
+# include <memory>
+DEAL_II_NAMESPACE_OPEN
+namespace std_cxx11
+{
+ using std::shared_ptr;
+ using std::enable_shared_from_this;
+}
+DEAL_II_NAMESPACE_CLOSE
+
+#else
+
+#include <boost/shared_ptr.hpp>
+#include <boost/enable_shared_from_this.hpp>
+DEAL_II_NAMESPACE_OPEN
+namespace std_cxx11
+{
+ using boost::shared_ptr;
+ using boost::enable_shared_from_this;
+}
+DEAL_II_NAMESPACE_CLOSE
+
+#endif
+
+#endif
--- /dev/null
+// ---------------------------------------------------------------------
+// $Id$
+//
+// Copyright (C) 2009 - 2013 by the deal.II authors
+//
+// This file is part of the deal.II library.
+//
+// The deal.II library is free software; you can use it, redistribute
+// it, and/or modify it under the terms of the GNU Lesser General
+// Public License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+// The full text of the license can be found in the file LICENSE at
+// the top level of the deal.II distribution.
+//
+// ---------------------------------------------------------------------
+
+#ifndef __deal2__std_cxx11_thread_h
+#define __deal2__std_cxx11_thread_h
+
+
+#include <deal.II/base/config.h>
+
+#ifdef DEAL_II_WITH_CXX11
+
+# include <thread>
+DEAL_II_NAMESPACE_OPEN
+namespace std_cxx11
+{
+ using std::thread;
+}
+DEAL_II_NAMESPACE_CLOSE
+
+#else
+
+# include <boost/thread.hpp>
+DEAL_II_NAMESPACE_OPEN
+namespace std_cxx11
+{
+ using boost::thread;
+}
+DEAL_II_NAMESPACE_CLOSE
+
+#endif
+
+#endif
--- /dev/null
+// ---------------------------------------------------------------------
+// $Id$
+//
+// Copyright (C) 2009 - 2013 by the deal.II authors
+//
+// This file is part of the deal.II library.
+//
+// The deal.II library is free software; you can use it, redistribute
+// it, and/or modify it under the terms of the GNU Lesser General
+// Public License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+// The full text of the license can be found in the file LICENSE at
+// the top level of the deal.II distribution.
+//
+// ---------------------------------------------------------------------
+
+#ifndef __deal2__std_cxx11_tuple_h
+#define __deal2__std_cxx11_tuple_h
+
+
+#include <deal.II/base/config.h>
+
+#ifdef DEAL_II_WITH_CXX11
+
+# include <tuple>
+DEAL_II_NAMESPACE_OPEN
+namespace std_cxx11
+{
+ using std::tuple;
+ using std::get;
+ using std::tuple_size;
+ using std::tuple_element;
+}
+DEAL_II_NAMESPACE_CLOSE
+
+#else
+
+#include <boost/tuple/tuple.hpp>
+DEAL_II_NAMESPACE_OPEN
+namespace std_cxx11
+{
+ using boost::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
+
+#endif
--- /dev/null
+// ---------------------------------------------------------------------
+// $Id$
+//
+// Copyright (C) 2012 - 2013 by the deal.II authors
+//
+// This file is part of the deal.II library.
+//
+// The deal.II library is free software; you can use it, redistribute
+// it, and/or modify it under the terms of the GNU Lesser General
+// Public License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+// The full text of the license can be found in the file LICENSE at
+// the top level of the deal.II distribution.
+//
+// ---------------------------------------------------------------------
+
+#ifndef __deal2__std_cxx11_type_traits_h
+#define __deal2__std_cxx11_type_traits_h
+
+
+#include <deal.II/base/config.h>
+
+#ifdef DEAL_II_WITH_CXX11
+
+# include <type_traits>
+DEAL_II_NAMESPACE_OPEN
+namespace std_cxx11
+{
+ // TODO: could fill up with more types from
+ // C++11 type traits
+ using std::is_pod;
+ using std::is_standard_layout;
+ using std::is_trivial;
+}
+DEAL_II_NAMESPACE_CLOSE
+
+#else
+
+#include <boost/type_traits.hpp>
+DEAL_II_NAMESPACE_OPEN
+namespace std_cxx11
+{
+ using boost::is_pod;
+
+ // 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;
+ };
+}
+DEAL_II_NAMESPACE_CLOSE
+
+#endif
+
+#endif
// ---------------------------------------------------------------------
// $Id$
//
-// Copyright (C) 2009 - 2013 by the deal.II authors
+// Copyright (C) 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
//
// ---------------------------------------------------------------------
-#ifndef __deal2__std_cxx1x_array_h
-#define __deal2__std_cxx1x_array_h
+// this file is deprecated. simply include the one we use now
+#include "../std_cxx11/array.h"
-
-#include <deal.II/base/config.h>
-
-#ifdef DEAL_II_WITH_CXX11
-
-# include <array>
-DEAL_II_NAMESPACE_OPEN
-namespace std_cxx1x
-{
- using std::array;
-}
-DEAL_II_NAMESPACE_CLOSE
-
-#else
-
-#include <boost/array.hpp>
-DEAL_II_NAMESPACE_OPEN
-namespace std_cxx1x
-{
- using boost::array;
-}
-DEAL_II_NAMESPACE_CLOSE
-
-#endif
-
-#endif
+// then allow using the old namespace name instead of the new one
+namespace std_cxx1x = std_cxx11;
// ---------------------------------------------------------------------
// $Id$
//
-// Copyright (C) 2009 - 2013 by the deal.II authors
+// Copyright (C) 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
//
// ---------------------------------------------------------------------
-#ifndef __deal2__std_cxx1x_bind_h
-#define __deal2__std_cxx1x_bind_h
+// this file is deprecated. simply include the one we use now
+#include "../std_cxx11/bind.h"
-
-#include <deal.II/base/config.h>
-
-#ifdef DEAL_II_WITH_CXX11
-
-# include <functional>
-
-DEAL_II_NAMESPACE_OPEN
-// in boost, the placeholders _1, _2, ... are in the global namespace. in
-// C++0x, they are in namespace std::placeholders, which makes them awkward to
-// use. import them into the deal.II::std_cxx1x namespace instead and do them
-// same below if we use boost instead.
-namespace std_cxx1x
-{
- using namespace std::placeholders;
- using std::bind;
- using std::ref;
- using std::cref;
- using std::reference_wrapper;
-}
-DEAL_II_NAMESPACE_CLOSE
-
-#else
-
-#include <boost/bind.hpp>
-
-DEAL_II_NAMESPACE_OPEN
-namespace std_cxx1x
-{
- 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;
-}
-DEAL_II_NAMESPACE_CLOSE
-
-#endif
-
-#endif
+// then allow using the old namespace name instead of the new one
+namespace std_cxx1x = std_cxx11;
// ---------------------------------------------------------------------
// $Id$
//
-// Copyright (C) 2009 - 2013 by the deal.II authors
+// Copyright (C) 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
//
// ---------------------------------------------------------------------
-#ifndef __deal2__std_cxx1x_condition_variable_h
-#define __deal2__std_cxx1x_condition_variable_h
+// this file is deprecated. simply include the one we use now
+#include "../std_cxx11/condition_variable.h"
-
-#include <deal.II/base/config.h>
-
-#ifdef DEAL_II_WITH_CXX11
-
-# include <condition_variable>
-DEAL_II_NAMESPACE_OPEN
-namespace std_cxx1x
-{
- using std::condition_variable;
- using std::unique_lock;
- using std::adopt_lock;
-}
-DEAL_II_NAMESPACE_CLOSE
-
-#else
-
-# include <boost/thread/condition_variable.hpp>
-DEAL_II_NAMESPACE_OPEN
-namespace std_cxx1x
-{
- using boost::condition_variable;
- using boost::unique_lock;
- using boost::adopt_lock;
-}
-DEAL_II_NAMESPACE_CLOSE
-
-#endif
-
-#endif
+// then allow using the old namespace name instead of the new one
+namespace std_cxx1x = std_cxx11;
// ---------------------------------------------------------------------
// $Id$
//
-// Copyright (C) 2009 - 2013 by the deal.II authors
+// Copyright (C) 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
//
// ---------------------------------------------------------------------
-#ifndef __deal2__std_cxx1x_function_h
-#define __deal2__std_cxx1x_function_h
+// this file is deprecated. simply include the one we use now
+#include "../std_cxx11/function.h"
-
-#include <deal.II/base/config.h>
-
-#ifdef DEAL_II_WITH_CXX11
-
-# include <functional>
-DEAL_II_NAMESPACE_OPEN
-namespace std_cxx1x
-{
- using std::function;
-}
-DEAL_II_NAMESPACE_CLOSE
-
-#else
-
-#include <boost/function.hpp>
-DEAL_II_NAMESPACE_OPEN
-namespace std_cxx1x
-{
- using boost::function;
-}
-DEAL_II_NAMESPACE_CLOSE
-
-#endif
-
-#endif
+// then allow using the old namespace name instead of the new one
+namespace std_cxx1x = std_cxx11;
// ---------------------------------------------------------------------
// $Id$
//
-// Copyright (C) 2009 - 2013 by the deal.II authors
+// Copyright (C) 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
//
// ---------------------------------------------------------------------
-#ifndef __deal2__std_cxx1x_mutex_h
-#define __deal2__std_cxx1x_mutex_h
+// this file is deprecated. simply include the one we use now
+#include "../std_cxx11/mutex.h"
-
-#include <deal.II/base/config.h>
-
-#ifdef DEAL_II_WITH_CXX11
-
-# include <mutex>
-DEAL_II_NAMESPACE_OPEN
-namespace std_cxx1x
-{
- using std::mutex;
-}
-DEAL_II_NAMESPACE_CLOSE
-
-#else
-
-# include <boost/thread/mutex.hpp>
-DEAL_II_NAMESPACE_OPEN
-namespace std_cxx1x
-{
- using boost::mutex;
-}
-DEAL_II_NAMESPACE_CLOSE
-
-#endif
-
-#endif
+// then allow using the old namespace name instead of the new one
+namespace std_cxx1x = std_cxx11;
// ---------------------------------------------------------------------
// $Id$
//
-// Copyright (C) 2009 - 2013 by the deal.II authors
+// Copyright (C) 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
//
// ---------------------------------------------------------------------
-#ifndef __deal2__std_cxx1x_shared_ptr_h
-#define __deal2__std_cxx1x_shared_ptr_h
+// this file is deprecated. simply include the one we use now
+#include "../std_cxx11/shared_ptr.h"
-
-#include <deal.II/base/config.h>
-
-#ifdef DEAL_II_WITH_CXX11
-
-# include <memory>
-DEAL_II_NAMESPACE_OPEN
-namespace std_cxx1x
-{
- using std::shared_ptr;
- using std::enable_shared_from_this;
-}
-DEAL_II_NAMESPACE_CLOSE
-
-#else
-
-#include <boost/shared_ptr.hpp>
-#include <boost/enable_shared_from_this.hpp>
-DEAL_II_NAMESPACE_OPEN
-namespace std_cxx1x
-{
- using boost::shared_ptr;
- using boost::enable_shared_from_this;
-}
-DEAL_II_NAMESPACE_CLOSE
-
-#endif
-
-#endif
+// then allow using the old namespace name instead of the new one
+namespace std_cxx1x = std_cxx11;
// ---------------------------------------------------------------------
// $Id$
//
-// Copyright (C) 2009 - 2013 by the deal.II authors
+// Copyright (C) 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
//
// ---------------------------------------------------------------------
-#ifndef __deal2__std_cxx1x_thread_h
-#define __deal2__std_cxx1x_thread_h
+// this file is deprecated. simply include the one we use now
+#include "../std_cxx11/thread.h"
-
-#include <deal.II/base/config.h>
-
-#ifdef DEAL_II_WITH_CXX11
-
-# include <thread>
-DEAL_II_NAMESPACE_OPEN
-namespace std_cxx1x
-{
- using std::thread;
-}
-DEAL_II_NAMESPACE_CLOSE
-
-#else
-
-# include <boost/thread.hpp>
-DEAL_II_NAMESPACE_OPEN
-namespace std_cxx1x
-{
- using boost::thread;
-}
-DEAL_II_NAMESPACE_CLOSE
-
-#endif
-
-#endif
+// then allow using the old namespace name instead of the new one
+namespace std_cxx1x = std_cxx11;
// ---------------------------------------------------------------------
// $Id$
//
-// Copyright (C) 2009 - 2013 by the deal.II authors
+// Copyright (C) 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
//
// ---------------------------------------------------------------------
-#ifndef __deal2__std_cxx1x_tuple_h
-#define __deal2__std_cxx1x_tuple_h
+// this file is deprecated. simply include the one we use now
+#include "../std_cxx11/tuple.h"
-
-#include <deal.II/base/config.h>
-
-#ifdef DEAL_II_WITH_CXX11
-
-# include <tuple>
-DEAL_II_NAMESPACE_OPEN
-namespace std_cxx1x
-{
- using std::tuple;
- using std::get;
- using std::tuple_size;
- using std::tuple_element;
-}
-DEAL_II_NAMESPACE_CLOSE
-
-#else
-
-#include <boost/tuple/tuple.hpp>
-DEAL_II_NAMESPACE_OPEN
-namespace std_cxx1x
-{
- using boost::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
-
-#endif
+// then allow using the old namespace name instead of the new one
+namespace std_cxx1x = std_cxx11;
// ---------------------------------------------------------------------
// $Id$
//
-// Copyright (C) 2012 - 2013 by the deal.II authors
+// Copyright (C) 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
//
// ---------------------------------------------------------------------
-#ifndef __deal2__std_cxx1x_type_traits_h
-#define __deal2__std_cxx1x_type_traits_h
+// this file is deprecated. simply include the one we use now
+#include "../std_cxx11/type_traits.h"
+// then allow using the old namespace name instead of the new one
+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_cxx1x
-{
- // TODO: could fill up with more types from
- // C++11 type traits
- using std::is_pod;
- using std::is_standard_layout;
- using std::is_trivial;
-}
-DEAL_II_NAMESPACE_CLOSE
-
-#else
-
-#include <boost/type_traits.hpp>
-DEAL_II_NAMESPACE_OPEN
-namespace std_cxx1x
-{
- using boost::is_pod;
-
- // 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;
- };
-}
-DEAL_II_NAMESPACE_CLOSE
-
-#endif
-
-#endif
#include <deal.II/base/config.h>
#include <deal.II/base/exceptions.h>
-#include <deal.II/base/std_cxx1x/tuple.h>
+#include <deal.II/base/std_cxx11/tuple.h>
#include <iterator>
*
* The template argument of the current
* class shall be of type
- * <code>std_cxx1x::tuple</code> with
+ * <code>std_cxx11::tuple</code> with
* arguments equal to the iterator types.
*
* This type, and the helper functions
operator< (const SynchronousIterators<Iterators> &a,
const SynchronousIterators<Iterators> &b)
{
- return std_cxx1x::get<0>(a.iterators) < std_cxx1x::get<0>(b.iterators);
+ return std_cxx11::get<0>(a.iterators) < std_cxx11::get<0>(b.iterators);
}
operator- (const SynchronousIterators<Iterators> &a,
const SynchronousIterators<Iterators> &b)
{
- Assert (std::distance (std_cxx1x::get<0>(b.iterators),
- std_cxx1x::get<0>(a.iterators)) >= 0,
+ Assert (std::distance (std_cxx11::get<0>(b.iterators),
+ std_cxx11::get<0>(a.iterators)) >= 0,
ExcInternalError());
- return std::distance (std_cxx1x::get<0>(b.iterators),
- std_cxx1x::get<0>(a.iterators));
+ return std::distance (std_cxx11::get<0>(b.iterators),
+ std_cxx11::get<0>(a.iterators));
}
*/
template <typename I1, typename I2>
inline
-void advance (std_cxx1x::tuple<I1,I2> &t,
+void advance (std_cxx11::tuple<I1,I2> &t,
const unsigned int n)
{
- std::advance (std_cxx1x::get<0>(t), n);
- std::advance (std_cxx1x::get<1>(t), n);
+ std::advance (std_cxx11::get<0>(t), n);
+ std::advance (std_cxx11::get<1>(t), n);
}
/**
*/
template <typename I1, typename I2, typename I3>
inline
-void advance (std_cxx1x::tuple<I1,I2,I3> &t,
+void advance (std_cxx11::tuple<I1,I2,I3> &t,
const unsigned int n)
{
- std::advance (std_cxx1x::get<0>(t), n);
- std::advance (std_cxx1x::get<1>(t), n);
- std::advance (std_cxx1x::get<2>(t), 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);
}
/**
template <typename I1, typename I2,
typename I3, typename I4>
inline
-void advance (std_cxx1x::tuple<I1,I2,I3, I4> &t,
+void advance (std_cxx11::tuple<I1,I2,I3, I4> &t,
const unsigned int n)
{
- std::advance (std_cxx1x::get<0>(t), n);
- std::advance (std_cxx1x::get<1>(t), n);
- std::advance (std_cxx1x::get<2>(t), n);
- std::advance (std_cxx1x::get<3>(t), 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);
}
*/
template <typename I1, typename I2>
inline
-void advance_by_one (std_cxx1x::tuple<I1,I2> &t)
+void advance_by_one (std_cxx11::tuple<I1,I2> &t)
{
- ++std_cxx1x::get<0>(t);
- ++std_cxx1x::get<1>(t);
+ ++std_cxx11::get<0>(t);
+ ++std_cxx11::get<1>(t);
}
/**
*/
template <typename I1, typename I2, typename I3>
inline
-void advance_by_one (std_cxx1x::tuple<I1,I2,I3> &t)
+void advance_by_one (std_cxx11::tuple<I1,I2,I3> &t)
{
- ++std_cxx1x::get<0>(t);
- ++std_cxx1x::get<1>(t);
- ++std_cxx1x::get<2>(t);
+ ++std_cxx11::get<0>(t);
+ ++std_cxx11::get<1>(t);
+ ++std_cxx11::get<2>(t);
}
/**
template <typename I1, typename I2,
typename I3, typename I4>
inline
-void advance_by_one (std_cxx1x::tuple<I1,I2,I3,I4> &t)
+void advance_by_one (std_cxx11::tuple<I1,I2,I3,I4> &t)
{
- ++std_cxx1x::get<0>(t);
- ++std_cxx1x::get<1>(t);
- ++std_cxx1x::get<2>(t);
- ++std_cxx1x::get<3>(t);
+ ++std_cxx11::get<0>(t);
+ ++std_cxx11::get<1>(t);
+ ++std_cxx11::get<2>(t);
+ ++std_cxx11::get<3>(t);
}
operator != (const SynchronousIterators<Iterators> &a,
const SynchronousIterators<Iterators> &b)
{
- return (std_cxx1x::get<0>(a.iterators) !=
- std_cxx1x::get<0>(b.iterators));
+ return (std_cxx11::get<0>(a.iterators) !=
+ std_cxx11::get<0>(b.iterators));
}
DEAL_II_NAMESPACE_CLOSE
#include <deal.II/base/config.h>
#include <deal.II/base/exceptions.h>
#include <deal.II/base/template_constraints.h>
-#include <deal.II/base/std_cxx1x/tuple.h>
-#include <deal.II/base/std_cxx1x/function.h>
-#include <deal.II/base/std_cxx1x/shared_ptr.h>
-#include <deal.II/base/std_cxx1x/bind.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_cxx1x/thread.h>
-# include <deal.II/base/std_cxx1x/mutex.h>
-# include <deal.II/base/std_cxx1x/condition_variable.h>
+# 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>
#endif
#include <iterator>
* Data object storing the
* mutex data
*/
- std_cxx1x::mutex mutex;
+ std_cxx11::mutex mutex;
/**
* Make the class implementing
*/
inline void wait (Mutex &mutex)
{
- std_cxx1x::unique_lock<std_cxx1x::mutex> lock(mutex.mutex,
- std_cxx1x::adopt_lock);
+ std_cxx11::unique_lock<std_cxx11::mutex> lock(mutex.mutex,
+ std_cxx11::adopt_lock);
condition_variable.wait (lock);
}
* Data object storing the
* necessary data.
*/
- std_cxx1x::condition_variable condition_variable;
+ std_cxx11::condition_variable condition_variable;
};
namespace internal
{
template <typename RT>
- inline void call (const std_cxx1x::function<RT ()> &function,
+ inline void call (const std_cxx11::function<RT ()> &function,
internal::return_value<RT> &ret_val)
{
ret_val.set (function());
}
- inline void call (const std_cxx1x::function<void ()> &function,
+ inline void call (const std_cxx11::function<void ()> &function,
internal::return_value<void> &)
{
function();
* for each number of arguments.
*/
template <typename RT, typename ArgList,
- int length = std_cxx1
x::tuple_size<ArgList>::value>
+ int length = std_cxx1
1::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_cxx1x::tuple_element<0,ArgList>::type);
+ typedef RT (type) (typename std_cxx11::tuple_element<0,ArgList>::type);
};
template <typename RT, typename ArgList>
struct fun_ptr_helper<RT, ArgList, 2>
{
- typedef RT (type) (typename std_cxx1x::tuple_element<0,ArgList>::type,
- typename std_cxx1x::tuple_element<1,ArgList>::type);
+ typedef RT (type) (typename std_cxx11::tuple_element<0,ArgList>::type,
+ typename std_cxx11::tuple_element<1,ArgList>::type);
};
template <typename RT, typename ArgList>
struct fun_ptr_helper<RT, ArgList, 3>
{
- typedef RT (type) (typename std_cxx1x::tuple_element<0,ArgList>::type,
- typename std_cxx1x::tuple_element<1,ArgList>::type,
- typename std_cxx1x::tuple_element<2,ArgList>::type);
+ 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);
};
template <typename RT, typename ArgList>
struct fun_ptr_helper<RT, ArgList, 4>
{
- typedef RT (type) (typename std_cxx1x::tuple_element<0,ArgList>::type,
- typename std_cxx1x::tuple_element<1,ArgList>::type,
- typename std_cxx1x::tuple_element<2,ArgList>::type,
- typename std_cxx1x::tuple_element<3,ArgList>::type);
+ 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);
};
template <typename RT, typename ArgList>
struct fun_ptr_helper<RT, ArgList, 5>
{
- typedef RT (type) (typename std_cxx1x::tuple_element<0,ArgList>::type,
- typename std_cxx1x::tuple_element<1,ArgList>::type,
- typename std_cxx1x::tuple_element<2,ArgList>::type,
- typename std_cxx1x::tuple_element<3,ArgList>::type,
- typename std_cxx1x::tuple_element<4,ArgList>::type);
+ 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);
};
template <typename RT, typename ArgList>
struct fun_ptr_helper<RT, ArgList, 6>
{
- typedef RT (type) (typename std_cxx1x::tuple_element<0,ArgList>::type,
- typename std_cxx1x::tuple_element<1,ArgList>::type,
- typename std_cxx1x::tuple_element<2,ArgList>::type,
- typename std_cxx1x::tuple_element<3,ArgList>::type,
- typename std_cxx1x::tuple_element<4,ArgList>::type,
- typename std_cxx1x::tuple_element<5,ArgList>::type);
+ 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);
};
template <typename RT, typename ArgList>
struct fun_ptr_helper<RT, ArgList, 7>
{
- typedef RT (type) (typename std_cxx1x::tuple_element<0,ArgList>::type,
- typename std_cxx1x::tuple_element<1,ArgList>::type,
- typename std_cxx1x::tuple_element<2,ArgList>::type,
- typename std_cxx1x::tuple_element<3,ArgList>::type,
- typename std_cxx1x::tuple_element<4,ArgList>::type,
- typename std_cxx1x::tuple_element<5,ArgList>::type,
- typename std_cxx1x::tuple_element<6,ArgList>::type);
+ 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);
};
template <typename RT, typename ArgList>
struct fun_ptr_helper<RT, ArgList, 8>
{
- typedef RT (type) (typename std_cxx1x::tuple_element<0,ArgList>::type,
- typename std_cxx1x::tuple_element<1,ArgList>::type,
- typename std_cxx1x::tuple_element<2,ArgList>::type,
- typename std_cxx1x::tuple_element<3,ArgList>::type,
- typename std_cxx1x::tuple_element<4,ArgList>::type,
- typename std_cxx1x::tuple_element<5,ArgList>::type,
- typename std_cxx1x::tuple_element<6,ArgList>::type,
- typename std_cxx1x::tuple_element<7,ArgList>::type);
+ 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);
};
template <typename RT, typename ArgList>
struct fun_ptr_helper<RT, ArgList, 9>
{
- typedef RT (type) (typename std_cxx1x::tuple_element<0,ArgList>::type,
- typename std_cxx1x::tuple_element<1,ArgList>::type,
- typename std_cxx1x::tuple_element<2,ArgList>::type,
- typename std_cxx1x::tuple_element<3,ArgList>::type,
- typename std_cxx1x::tuple_element<4,ArgList>::type,
- typename std_cxx1x::tuple_element<5,ArgList>::type,
- typename std_cxx1x::tuple_element<6,ArgList>::type,
- typename std_cxx1x::tuple_element<7,ArgList>::type,
- typename std_cxx1x::tuple_element<8,ArgList>::type);
+ 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);
};
template <typename RT, typename ArgList>
struct fun_ptr_helper<RT, ArgList, 10>
{
- typedef RT (type) (typename std_cxx1x::tuple_element<0,ArgList>::type,
- typename std_cxx1x::tuple_element<1,ArgList>::type,
- typename std_cxx1x::tuple_element<2,ArgList>::type,
- typename std_cxx1x::tuple_element<3,ArgList>::type,
- typename std_cxx1x::tuple_element<4,ArgList>::type,
- typename std_cxx1x::tuple_element<5,ArgList>::type,
- typename std_cxx1x::tuple_element<6,ArgList>::type,
- typename std_cxx1x::tuple_element<7,ArgList>::type,
- typename std_cxx1x::tuple_element<8,ArgList>::type,
- typename std_cxx1x::tuple_element<9,ArgList>::type);
+ 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);
};
* An object that represents the
* thread started.
*/
- std_cxx1x::thread thread;
+ std_cxx11::thread thread;
/**
* An object that will hold the value
* This makes sure the object stays
* alive until the thread exits.
*/
- std_cxx1x::shared_ptr<return_value<RT> > ret_val;
+ std_cxx11::shared_ptr<return_value<RT> > ret_val;
/**
* A bool variable that is initially
* it put its return value
* into the ret_val object.
*/
- void start (const std_cxx1x::function<RT ()> &function)
+ void start (const std_cxx11::function<RT ()> &function)
{
thread_is_active = true;
ret_val.reset(new return_value<RT>());
- thread = std_cxx1x::thread (thread_entry_point, function, ret_val);
+ thread = std_cxx11::thread (thread_entry_point, function, ret_val);
}
* thread.
*/
static
- void thread_entry_point (const std_cxx1x::function<RT ()> function,
- std_cxx1x::shared_ptr<return_value<RT> > ret_val)
+ void thread_entry_point (const std_cxx11::function<RT ()> function,
+ std_cxx11::shared_ptr<return_value<RT> > ret_val)
{
// call the function
// in question. since an
* returned by the function called on
* the thread.
*/
- std_cxx1x::shared_ptr<return_value<RT> > ret_val;
+ std_cxx11::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_cxx1x::function<RT ()> &function)
+ void start (const std_cxx11::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_cxx1x::function<RT ()> &function)
+ Thread (const std_cxx11::function<RT ()> &function)
:
thread_descriptor (new internal::ThreadDescriptor<RT>())
{
* as long as there is at least
* one subscriber to it.
*/
- std_cxx1x::shared_ptr<internal::ThreadDescriptor<RT> > thread_descriptor;
+ std_cxx11::shared_ptr<internal::ThreadDescriptor<RT> > thread_descriptor;
};
{
/**
* A general template that returns
- * std_cxx1x::ref(t) if t is of reference
+ * std_cxx11::ref(t) if t is of reference
* type, and t otherwise.
*
* The case that t is of reference type
/**
* A general template that returns
- * std_cxx1x::ref(t) if t is of reference
+ * std_cxx11::ref(t) if t is of reference
* type, and t otherwise.
*
* The case that t is of reference type
template <typename T>
struct maybe_make_ref<T &>
{
- static std_cxx1x::reference_wrapper<T> act (T &t)
+ static std_cxx11::reference_wrapper<T> act (T &t)
{
- return std_cxx1x::ref(t);
+ return std_cxx11::ref(t);
}
};
}
: function (*function)
{}
- fun_encapsulator (const std_cxx1x::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
+ fun_encapsulator (const std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
: function (function)
{}
}
private:
- std_cxx1x::function<typename internal::fun_ptr<RT,ArgList>::type> function;
+ std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> function;
};
/**
: function (*function)
{}
- fun_encapsulator (const std_cxx1x::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
+ fun_encapsulator (const std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
: function (function)
{}
inline
Thread<RT>
- operator() (typename std_cxx1x::tuple_element<0,ArgList>::type arg1)
+ operator() (typename std_cxx11::tuple_element<0,ArgList>::type arg1)
{
return
Thread<RT>
- (std_cxx1x::bind (function,
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<0,ArgList>::type>::act(arg1)));
+ (std_cxx11::bind (function,
+ internal::maybe_make_ref<typename std_cxx11::tuple_element<0,ArgList>::type>::act(arg1)));
}
private:
- std_cxx1x::function<typename internal::fun_ptr<RT,ArgList>::type> function;
+ std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> function;
};
/**
: function (*function)
{}
- fun_encapsulator (const std_cxx1x::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
+ fun_encapsulator (const std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
: function (function)
{}
inline
Thread<RT>
- operator() (typename std_cxx1x::tuple_element<0,ArgList>::type arg1,
- typename std_cxx1x::tuple_element<1,ArgList>::type arg2)
+ operator() (typename std_cxx11::tuple_element<0,ArgList>::type arg1,
+ typename std_cxx11::tuple_element<1,ArgList>::type arg2)
{
return
Thread<RT>
- (std_cxx1x::bind (function,
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<0,ArgList>::type>::act(arg1),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<1,ArgList>::type>::act(arg2)));
+ (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)));
}
private:
- std_cxx1x::function<typename internal::fun_ptr<RT,ArgList>::type> function;
+ std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> function;
};
/**
: function (*function)
{}
- fun_encapsulator (const std_cxx1x::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
+ fun_encapsulator (const std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
: function (function)
{}
inline
Thread<RT>
- operator() (typename std_cxx1x::tuple_element<0,ArgList>::type arg1,
- typename std_cxx1x::tuple_element<1,ArgList>::type arg2,
- typename std_cxx1x::tuple_element<2,ArgList>::type arg3)
+ 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)
{
return
Thread<RT>
- (std_cxx1x::bind (function,
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<0,ArgList>::type>::act(arg1),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<1,ArgList>::type>::act(arg2),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<2,ArgList>::type>::act(arg3)));
+ (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)));
}
private:
- std_cxx1x::function<typename internal::fun_ptr<RT,ArgList>::type> function;
+ std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> function;
};
/**
: function (*function)
{}
- fun_encapsulator (const std_cxx1x::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
+ fun_encapsulator (const std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
: function (function)
{}
inline
Thread<RT>
- operator() (typename std_cxx1x::tuple_element<0,ArgList>::type arg1,
- typename std_cxx1x::tuple_element<1,ArgList>::type arg2,
- typename std_cxx1x::tuple_element<2,ArgList>::type arg3,
- typename std_cxx1x::tuple_element<3,ArgList>::type arg4)
+ 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)
{
return
Thread<RT>
- (std_cxx1x::bind (function,
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<0,ArgList>::type>::act(arg1),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<1,ArgList>::type>::act(arg2),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<2,ArgList>::type>::act(arg3),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<3,ArgList>::type>::act(arg4)));
+ (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)));
}
private:
- std_cxx1x::function<typename internal::fun_ptr<RT,ArgList>::type> function;
+ std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> function;
};
/**
: function (*function)
{}
- fun_encapsulator (const std_cxx1x::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
+ fun_encapsulator (const std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
: function (function)
{}
inline
Thread<RT>
- operator() (typename std_cxx1x::tuple_element<0,ArgList>::type arg1,
- typename std_cxx1x::tuple_element<1,ArgList>::type arg2,
- typename std_cxx1x::tuple_element<2,ArgList>::type arg3,
- typename std_cxx1x::tuple_element<3,ArgList>::type arg4,
- typename std_cxx1x::tuple_element<4,ArgList>::type arg5)
+ 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)
{
return
Thread<RT>
- (std_cxx1x::bind (function,
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<0,ArgList>::type>::act(arg1),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<1,ArgList>::type>::act(arg2),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<2,ArgList>::type>::act(arg3),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<3,ArgList>::type>::act(arg4),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<4,ArgList>::type>::act(arg5)));
+ (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)));
}
private:
- std_cxx1x::function<typename internal::fun_ptr<RT,ArgList>::type> function;
+ std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> function;
};
/**
: function (*function)
{}
- fun_encapsulator (const std_cxx1x::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
+ fun_encapsulator (const std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
: function (function)
{}
inline
Thread<RT>
- operator() (typename std_cxx1x::tuple_element<0,ArgList>::type arg1,
- typename std_cxx1x::tuple_element<1,ArgList>::type arg2,
- typename std_cxx1x::tuple_element<2,ArgList>::type arg3,
- typename std_cxx1x::tuple_element<3,ArgList>::type arg4,
- typename std_cxx1x::tuple_element<4,ArgList>::type arg5,
- typename std_cxx1x::tuple_element<5,ArgList>::type arg6)
+ 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)
{
return
Thread<RT>
- (std_cxx1x::bind (function,
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<0,ArgList>::type>::act(arg1),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<1,ArgList>::type>::act(arg2),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<2,ArgList>::type>::act(arg3),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<3,ArgList>::type>::act(arg4),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<4,ArgList>::type>::act(arg5),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<5,ArgList>::type>::act(arg6)));
+ (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)));
}
private:
- std_cxx1x::function<typename internal::fun_ptr<RT,ArgList>::type> function;
+ std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> function;
};
/**
: function (*function)
{}
- fun_encapsulator (const std_cxx1x::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
+ fun_encapsulator (const std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
: function (function)
{}
inline
Thread<RT>
- operator() (typename std_cxx1x::tuple_element<0,ArgList>::type arg1,
- typename std_cxx1x::tuple_element<1,ArgList>::type arg2,
- typename std_cxx1x::tuple_element<2,ArgList>::type arg3,
- typename std_cxx1x::tuple_element<3,ArgList>::type arg4,
- typename std_cxx1x::tuple_element<4,ArgList>::type arg5,
- typename std_cxx1x::tuple_element<5,ArgList>::type arg6,
- typename std_cxx1x::tuple_element<6,ArgList>::type arg7)
+ 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)
{
return
Thread<RT>
- (std_cxx1x::bind (function,
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<0,ArgList>::type>::act(arg1),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<1,ArgList>::type>::act(arg2),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<2,ArgList>::type>::act(arg3),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<3,ArgList>::type>::act(arg4),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<4,ArgList>::type>::act(arg5),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<5,ArgList>::type>::act(arg6),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<6,ArgList>::type>::act(arg7)));
+ (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)));
}
private:
- std_cxx1x::function<typename internal::fun_ptr<RT,ArgList>::type> function;
+ std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> function;
};
/**
: function (*function)
{}
- fun_encapsulator (const std_cxx1x::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
+ fun_encapsulator (const std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
: function (function)
{}
inline
Thread<RT>
- operator() (typename std_cxx1x::tuple_element<0,ArgList>::type arg1,
- typename std_cxx1x::tuple_element<1,ArgList>::type arg2,
- typename std_cxx1x::tuple_element<2,ArgList>::type arg3,
- typename std_cxx1x::tuple_element<3,ArgList>::type arg4,
- typename std_cxx1x::tuple_element<4,ArgList>::type arg5,
- typename std_cxx1x::tuple_element<5,ArgList>::type arg6,
- typename std_cxx1x::tuple_element<6,ArgList>::type arg7,
- typename std_cxx1x::tuple_element<7,ArgList>::type arg8)
+ 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)
{
return
Thread<RT>
- (std_cxx1x::bind (function,
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<0,ArgList>::type>::act(arg1),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<1,ArgList>::type>::act(arg2),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<2,ArgList>::type>::act(arg3),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<3,ArgList>::type>::act(arg4),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<4,ArgList>::type>::act(arg5),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<5,ArgList>::type>::act(arg6),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<6,ArgList>::type>::act(arg7),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<7,ArgList>::type>::act(arg8)));
+ (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)));
}
private:
- std_cxx1x::function<typename internal::fun_ptr<RT,ArgList>::type> function;
+ std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> function;
};
/**
: function (*function)
{}
- fun_encapsulator (const std_cxx1x::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
+ fun_encapsulator (const std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> &function)
: function (function)
{}
inline
Thread<RT>
- operator() (typename std_cxx1x::tuple_element<0,ArgList>::type arg1,
- typename std_cxx1x::tuple_element<1,ArgList>::type arg2,
- typename std_cxx1x::tuple_element<2,ArgList>::type arg3,
- typename std_cxx1x::tuple_element<3,ArgList>::type arg4,
- typename std_cxx1x::tuple_element<4,ArgList>::type arg5,
- typename std_cxx1x::tuple_element<5,ArgList>::type arg6,
- typename std_cxx1x::tuple_element<6,ArgList>::type arg7,
- typename std_cxx1x::tuple_element<7,ArgList>::type arg8,
- typename std_cxx1x::tuple_element<8,ArgList>::type arg9)
+ 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)
{
return
Thread<RT>
- (std_cxx1x::bind (function,
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<0,ArgList>::type>::act(arg1),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<1,ArgList>::type>::act(arg2),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<2,ArgList>::type>::act(arg3),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<3,ArgList>::type>::act(arg4),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<4,ArgList>::type>::act(arg5),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<5,ArgList>::type>::act(arg6),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<6,ArgList>::type>::act(arg7),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<7,ArgList>::type>::act(arg8),
- internal::maybe_make_ref<typename std_cxx1x::tuple_element<8,ArgList>::type>::act(arg9)));
+ (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)));
}
private:
- std_cxx1x::function<typename internal::fun_ptr<RT,ArgList>::type> function;
+ std_cxx11::function<typename internal::fun_ptr<RT,ArgList>::type> function;
};
}
*/
template <typename RT>
inline
- internal::fun_encapsulator<RT,std_cxx1x::tuple<>,0>
+ internal::fun_encapsulator<RT,std_cxx11::tuple<>,0>
spawn (RT (*fun_ptr)()) DEAL_II_DEPRECATED;
template <typename RT>
inline
- internal::fun_encapsulator<RT,std_cxx1x::tuple<>,0>
+ internal::fun_encapsulator<RT,std_cxx11::tuple<>,0>
spawn (RT (*fun_ptr)())
{
return fun_ptr;
*/
template <typename RT, typename C>
inline
- internal::fun_encapsulator<RT,std_cxx1x::tuple<>,0>
+ internal::fun_encapsulator<RT,std_cxx11::tuple<>,0>
spawn (C &c, RT (C::*fun_ptr)()) DEAL_II_DEPRECATED;
template <typename RT, typename C>
inline
- internal::fun_encapsulator<RT,std_cxx1x::tuple<>,0>
+ internal::fun_encapsulator<RT,std_cxx11::tuple<>,0>
spawn (C &c, RT (C::*fun_ptr)())
{
return
- std_cxx1x::function<typename internal::fun_ptr<RT,std_cxx1x::tuple<> >::type>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::ref(c)));
+ std_cxx11::function<typename internal::fun_ptr<RT,std_cxx11::tuple<> >::type>
+ (std_cxx11::bind(fun_ptr, std_cxx11::ref(c)));
}
/**
*/
template <typename RT, typename C>
inline
- internal::fun_encapsulator<RT,std_cxx1x::tuple<>,0>
+ internal::fun_encapsulator<RT,std_cxx11::tuple<>,0>
spawn (const C &c, RT (C::*fun_ptr)() const) DEAL_II_DEPRECATED;
template <typename RT, typename C>
inline
- internal::fun_encapsulator<RT,std_cxx1x::tuple<>,0>
+ internal::fun_encapsulator<RT,std_cxx11::tuple<>,0>
spawn (const C &c, RT (C::*fun_ptr)() const)
{
return
- std_cxx1x::function<typename internal::fun_ptr<RT,std_cxx1x::tuple<> >::type>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::cref(c)));
+ std_cxx11::function<typename internal::fun_ptr<RT,std_cxx11::tuple<> >::type>
+ (std_cxx11::bind(fun_ptr, std_cxx11::cref(c)));
}
*/
template <typename RT, typename Arg1>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1>,1>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1>,1>
spawn (RT (*fun_ptr)(Arg1)) DEAL_II_DEPRECATED;
template <typename RT, typename Arg1>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1>,1>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1>,1>
spawn (RT (*fun_ptr)(Arg1))
{
return fun_ptr;
*/
template <typename RT, typename C, typename Arg1>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1>,1>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1>,1>
spawn (C &c, RT (C::*fun_ptr)(Arg1)) DEAL_II_DEPRECATED;
template <typename RT, typename C, typename Arg1>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1>,1>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1>,1>
spawn (C &c, RT (C::*fun_ptr)(Arg1))
{
return
- std_cxx1
x::function<typename internal::fun_ptr<RT,std_cxx1x::tuple<Arg1> >::type>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::ref(c), std_cxx1x::_1));
+ std_cxx1
1::function<typename internal::fun_ptr<RT,std_cxx11::tuple<Arg1> >::type>
+ (std_cxx11::bind(fun_ptr, std_cxx11::ref(c), std_cxx11::_1));
}
/**
*/
template <typename RT, typename C, typename Arg1>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1>,1>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1>,1>
spawn (const C &c, RT (C::*fun_ptr)(Arg1) const) DEAL_II_DEPRECATED;
template <typename RT, typename C, typename Arg1>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1>,1>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1>,1>
spawn (const C &c, RT (C::*fun_ptr)(Arg1) const)
{
return
- std_cxx1
x::function<typename internal::fun_ptr<RT,std_cxx1x::tuple<Arg1> >::type>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::cref(c), std_cxx1x::_1));
+ std_cxx1
1::function<typename internal::fun_ptr<RT,std_cxx11::tuple<Arg1> >::type>
+ (std_cxx11::bind(fun_ptr, std_cxx11::cref(c), std_cxx11::_1));
}
*/
template <typename RT, typename Arg1, typename Arg2>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2>,2>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2>,2>
spawn (RT (*fun_ptr)(Arg1,Arg2)) DEAL_II_DEPRECATED;
template <typename RT, typename Arg1, typename Arg2>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2>,2>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2>,2>
spawn (RT (*fun_ptr)(Arg1,Arg2))
{
return fun_ptr;
*/
template <typename RT, typename C, typename Arg1, typename Arg2>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2>,2>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2>,2>
spawn (C &c, RT (C::*fun_ptr)(Arg1,Arg2)) DEAL_II_DEPRECATED;
template <typename RT, typename C, typename Arg1, typename Arg2>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2>,2>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2>,2>
spawn (C &c, RT (C::*fun_ptr)(Arg1,Arg2))
{
return
- std_cxx1
x::function<typename internal::fun_ptr<RT,std_cxx1x::tuple<Arg1,Arg2> >::type>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::ref(c), std_cxx1x::_1, std_cxx1x::_2));
+ std_cxx1
1::function<typename internal::fun_ptr<RT,std_cxx11::tuple<Arg1,Arg2> >::type>
+ (std_cxx11::bind(fun_ptr, std_cxx11::ref(c), std_cxx11::_1, std_cxx11::_2));
}
/**
*/
template <typename RT, typename C, typename Arg1, typename Arg2>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2>,2>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2>,2>
spawn (const C &c, RT (C::*fun_ptr)(Arg1,Arg2) const) DEAL_II_DEPRECATED;
template <typename RT, typename C, typename Arg1, typename Arg2>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2>,2>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2>,2>
spawn (const C &c, RT (C::*fun_ptr)(Arg1,Arg2) const)
{
return
- std_cxx1
x::function<typename internal::fun_ptr<RT,std_cxx1x::tuple<Arg1,Arg2> >::type>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::cref(c), std_cxx1x::_1, std_cxx1x::_2));
+ std_cxx1
1::function<typename internal::fun_ptr<RT,std_cxx11::tuple<Arg1,Arg2> >::type>
+ (std_cxx11::bind(fun_ptr, std_cxx11::cref(c), std_cxx11::_1, std_cxx11::_2));
}
template <typename RT,
typename Arg1, typename Arg2, typename Arg3>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3>,3>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3>,3>
spawn (RT (*fun_ptr)(Arg1,Arg2,Arg3)) DEAL_II_DEPRECATED;
template <typename RT,
typename Arg1, typename Arg2, typename Arg3>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3>,3>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3>,3>
spawn (RT (*fun_ptr)(Arg1,Arg2,Arg3))
{
return fun_ptr;
template <typename RT, typename C,
typename Arg1, typename Arg2, typename Arg3>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3>,3>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3>,3>
spawn (C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3)) DEAL_II_DEPRECATED;
template <typename RT, typename C,
typename Arg1, typename Arg2, typename Arg3>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3>,3>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3>,3>
spawn (C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3))
{
return
- std_cxx1
x::function<typename internal::fun_ptr<RT,std_cxx1x::tuple<Arg1,Arg2,Arg3> >::type>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::ref(c), std_cxx1x::_1, std_cxx1x::_2, std_cxx1x::_3));
+ std_cxx1
1::function<typename internal::fun_ptr<RT,std_cxx11::tuple<Arg1,Arg2,Arg3> >::type>
+ (std_cxx11::bind(fun_ptr, std_cxx11::ref(c), std_cxx11::_1, std_cxx11::_2, std_cxx11::_3));
}
/**
template <typename RT, typename C,
typename Arg1, typename Arg2, typename Arg3>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3>,3>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3>,3>
spawn (const C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3) const) DEAL_II_DEPRECATED;
template <typename RT, typename C,
typename Arg1, typename Arg2, typename Arg3>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3>,3>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3>,3>
spawn (const C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3) const)
{
return
- std_cxx1
x::function<typename internal::fun_ptr<RT,std_cxx1x::tuple<Arg1,Arg2,Arg3> >::type>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::cref(c), std_cxx1x::_1, std_cxx1x::_2, std_cxx1x::_3));
+ std_cxx1
1::function<typename internal::fun_ptr<RT,std_cxx11::tuple<Arg1,Arg2,Arg3> >::type>
+ (std_cxx11::bind(fun_ptr, std_cxx11::cref(c), std_cxx11::_1, std_cxx11::_2, std_cxx11::_3));
}
template <typename RT,
typename Arg1, typename Arg2, typename Arg3, typename Arg4>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3, Arg4>,4>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3, Arg4>,4>
spawn (RT (*fun_ptr)(Arg1,Arg2,Arg3,Arg4)) DEAL_II_DEPRECATED;
template <typename RT,
typename Arg1, typename Arg2, typename Arg3, typename Arg4>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3, Arg4>,4>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3, Arg4>,4>
spawn (RT (*fun_ptr)(Arg1,Arg2,Arg3,Arg4))
{
return fun_ptr;
template <typename RT, typename C,
typename Arg1, typename Arg2, typename Arg3, typename Arg4>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3, Arg4>,4>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3, Arg4>,4>
spawn (C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4)) DEAL_II_DEPRECATED;
template <typename RT, typename C,
typename Arg1, typename Arg2, typename Arg3, typename Arg4>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3, Arg4>,4>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3, Arg4>,4>
spawn (C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4))
{
return
- std_cxx1
x::function<typename internal::fun_ptr<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3, Arg4> >::type>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::ref(c), std_cxx1x::_1, std_cxx1x::_2, std_cxx1x::_3, std_cxx1x::_4));
+ std_cxx1
1::function<typename internal::fun_ptr<RT,std_cxx11::tuple<Arg1, Arg2, Arg3, Arg4> >::type>
+ (std_cxx11::bind(fun_ptr, std_cxx11::ref(c), std_cxx11::_1, std_cxx11::_2, std_cxx11::_3, std_cxx11::_4));
}
/**
template <typename RT, typename C,
typename Arg1, typename Arg2, typename Arg3, typename Arg4>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3, Arg4>,4>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3, Arg4>,4>
spawn (const C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4) const) DEAL_II_DEPRECATED;
template <typename RT, typename C,
typename Arg1, typename Arg2, typename Arg3, typename Arg4>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3, Arg4>,4>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3, Arg4>,4>
spawn (const C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4) const)
{
return
- std_cxx1
x::function<typename internal::fun_ptr<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3, Arg4> >::type>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::cref(c), std_cxx1x::_1, std_cxx1x::_2, std_cxx1x::_3, std_cxx1x::_4));
+ std_cxx1
1::function<typename internal::fun_ptr<RT,std_cxx11::tuple<Arg1, Arg2, Arg3, Arg4> >::type>
+ (std_cxx11::bind(fun_ptr, std_cxx11::cref(c), std_cxx11::_1, std_cxx11::_2, std_cxx11::_3, std_cxx11::_4));
}
typename Arg1, typename Arg2, typename Arg3,
typename Arg4, typename Arg5>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5>,5>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3, Arg4, Arg5>,5>
spawn (RT (*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5)) DEAL_II_DEPRECATED;
typename Arg1, typename Arg2, typename Arg3,
typename Arg4, typename Arg5>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5>,5>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3, Arg4, Arg5>,5>
spawn (RT (*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5))
{
return fun_ptr;
typename Arg1, typename Arg2, typename Arg3,
typename Arg4, typename Arg5>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5>,5>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3, Arg4, Arg5>,5>
spawn (C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5)) DEAL_II_DEPRECATED;
typename Arg1, typename Arg2, typename Arg3,
typename Arg4, typename Arg5>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5>,5>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3, Arg4, Arg5>,5>
spawn (C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5))
{
return
- std_cxx1
x::function<typename internal::fun_ptr<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5> >::type>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::ref(c), std_cxx1x::_1, std_cxx1x::_2, std_cxx1x::_3, std_cxx1x::_4, std_cxx1x::_5));
+ std_cxx1
1::function<typename internal::fun_ptr<RT,std_cxx11::tuple<Arg1, Arg2, Arg3, Arg4, Arg5> >::type>
+ (std_cxx11::bind(fun_ptr, std_cxx11::ref(c), std_cxx11::_1, std_cxx11::_2, std_cxx11::_3, std_cxx11::_4, std_cxx11::_5));
}
/**
typename Arg1, typename Arg2, typename Arg3,
typename Arg4, typename Arg5>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5>,5>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3, Arg4, Arg5>,5>
spawn (const C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5) const) DEAL_II_DEPRECATED;
typename Arg1, typename Arg2, typename Arg3,
typename Arg4, typename Arg5>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5>,5>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3, Arg4, Arg5>,5>
spawn (const C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5) const)
{
return
- std_cxx1
x::function<typename internal::fun_ptr<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5> >::type>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::cref(c), std_cxx1x::_1, std_cxx1x::_2, std_cxx1x::_3, std_cxx1x::_4, std_cxx1x::_5));
+ std_cxx1
1::function<typename internal::fun_ptr<RT,std_cxx11::tuple<Arg1, Arg2, Arg3, Arg4, Arg5> >::type>
+ (std_cxx11::bind(fun_ptr, std_cxx11::cref(c), std_cxx11::_1, std_cxx11::_2, std_cxx11::_3, std_cxx11::_4, std_cxx11::_5));
}
typename Arg1, typename Arg2, typename Arg3,
typename Arg4, typename Arg5, typename Arg6>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6>,6>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6>,6>
spawn (RT (*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,Arg6)) DEAL_II_DEPRECATED;
typename Arg1, typename Arg2, typename Arg3,
typename Arg4, typename Arg5, typename Arg6>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6>,6>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6>,6>
spawn (RT (*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,Arg6))
{
return fun_ptr;
typename Arg1, typename Arg2, typename Arg3,
typename Arg4, typename Arg5, typename Arg6>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6>,6>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6>,6>
spawn (C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,Arg6)) DEAL_II_DEPRECATED;
typename Arg1, typename Arg2, typename Arg3,
typename Arg4, typename Arg5, typename Arg6>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6>,6>
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6>,6>
spawn (C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,Arg6))
{
return
- std_cxx1
x::function<typename internal::fun_ptr<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6> >::type>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::ref(c), std_cxx1x::_1, std_cxx1x::_2, std_cxx1x::_3, std_cxx1x::_4, std_cxx1x::_5, std_cxx1x::_6));
+ std_cxx1
1::function<typename internal::fun_ptr<RT,std_cxx11::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6> >::type>
+ (std_cxx11::bind(fun_ptr, std_cxx11::ref(c), std_cxx11::_1, std_cxx11::_2, std_cxx11::_3, std_cxx11::_4, std_cxx11::_5, std_cxx11::_6));
}
/**
typename Arg4, typename Arg5, typename Arg6>
inline
internal::fun_encapsulator<RT,
- std_cxx1
x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6>,6>
+ std_cxx1
1::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6>,6>
spawn (const C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,Arg6) const) DEAL_II_DEPRECATED;
typename Arg4, typename Arg5, typename Arg6>
inline
internal::fun_encapsulator<RT,
- std_cxx1
x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6>,6>
+ std_cxx1
1::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6>,6>
spawn (const C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,Arg6) const)
{
return
- std_cxx1
x::function<typename internal::fun_ptr<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6> >::type>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::cref(c), std_cxx1x::_1, std_cxx1x::_2, std_cxx1x::_3, std_cxx1x::_4, std_cxx1x::_5, std_cxx1x::_6));
+ std_cxx1
1::function<typename internal::fun_ptr<RT,std_cxx11::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6> >::type>
+ (std_cxx11::bind(fun_ptr, std_cxx11::cref(c), std_cxx11::_1, std_cxx11::_2, std_cxx11::_3, std_cxx11::_4, std_cxx11::_5, std_cxx11::_6));
}
typename Arg4, typename Arg5, typename Arg6,
typename Arg7>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3,
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3,
Arg4, Arg5, Arg6, Arg7>,7>
spawn (RT (*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,Arg6,Arg7)) DEAL_II_DEPRECATED;
typename Arg4, typename Arg5, typename Arg6,
typename Arg7>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3,
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3,
Arg4, Arg5, Arg6, Arg7>,7>
spawn (RT (*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,Arg6,Arg7))
{
typename Arg4, typename Arg5, typename Arg6,
typename Arg7>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3,
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3,
Arg4, Arg5, Arg6, Arg7>,7>
spawn (C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,Arg6,Arg7)) DEAL_II_DEPRECATED;
typename Arg4, typename Arg5, typename Arg6,
typename Arg7>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3,
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3,
Arg4, Arg5, Arg6, Arg7>,7>
spawn (C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,Arg6,Arg7))
{
return
- std_cxx1
x::function<typename internal::fun_ptr<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7> >::type>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::ref(c), std_cxx1x::_1, std_cxx1x::_2, std_cxx1x::_3, std_cxx1x::_4, std_cxx1x::_5, std_cxx1x::_6, std_cxx1x::_7));
+ std_cxx1
1::function<typename internal::fun_ptr<RT,std_cxx11::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7> >::type>
+ (std_cxx11::bind(fun_ptr, std_cxx11::ref(c), std_cxx11::_1, std_cxx11::_2, std_cxx11::_3, std_cxx11::_4, std_cxx11::_5, std_cxx11::_6, std_cxx11::_7));
}
/**
typename Arg7>
inline
internal::fun_encapsulator<RT,
- std_cxx1
x::tuple<Arg1, Arg2, Arg3,
+ std_cxx1
1::tuple<Arg1, Arg2, Arg3,
Arg4, Arg5, Arg6, Arg7>,7>
spawn (const C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,Arg6,Arg7) const) DEAL_II_DEPRECATED;
typename Arg7>
inline
internal::fun_encapsulator<RT,
- std_cxx1
x::tuple<Arg1, Arg2, Arg3,
+ std_cxx1
1::tuple<Arg1, Arg2, Arg3,
Arg4, Arg5, Arg6, Arg7>,7>
spawn (const C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,Arg6,Arg7) const)
{
return
- std_cxx1
x::function<typename internal::fun_ptr<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7> >::type>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::cref(c), std_cxx1x::_1, std_cxx1x::_2, std_cxx1x::_3, std_cxx1x::_4, std_cxx1x::_5, std_cxx1x::_6, std_cxx1x::_7));
+ std_cxx1
1::function<typename internal::fun_ptr<RT,std_cxx11::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7> >::type>
+ (std_cxx11::bind(fun_ptr, std_cxx11::cref(c), std_cxx11::_1, std_cxx11::_2, std_cxx11::_3, std_cxx11::_4, std_cxx11::_5, std_cxx11::_6, std_cxx11::_7));
}
typename Arg4, typename Arg5, typename Arg6,
typename Arg7, typename Arg8>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3,
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3,
Arg4, Arg5, Arg6,
Arg7, Arg8>,8>
spawn (RT (*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,
typename Arg4, typename Arg5, typename Arg6,
typename Arg7, typename Arg8>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3,
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3,
Arg4, Arg5, Arg6,
Arg7, Arg8>,8>
spawn (RT (*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,
typename Arg4, typename Arg5, typename Arg6,
typename Arg7, typename Arg8>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3,
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3,
Arg4, Arg5, Arg6,
Arg7, Arg8>,8>
spawn (C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,
typename Arg4, typename Arg5, typename Arg6,
typename Arg7, typename Arg8>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3,
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3,
Arg4, Arg5, Arg6,
Arg7, Arg8>,8>
spawn (C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,
Arg6,Arg7,Arg8))
{
return
- std_cxx1
x::function<typename internal::fun_ptr<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8> >::type>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::ref(c), std_cxx1x::_1, std_cxx1x::_2, std_cxx1x::_3, std_cxx1x::_4, std_cxx1x::_5, std_cxx1x::_6, std_cxx1x::_7, std_cxx1x::_8));
+ std_cxx1
1::function<typename internal::fun_ptr<RT,std_cxx11::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8> >::type>
+ (std_cxx11::bind(fun_ptr, std_cxx11::ref(c), std_cxx11::_1, std_cxx11::_2, std_cxx11::_3, std_cxx11::_4, std_cxx11::_5, std_cxx11::_6, std_cxx11::_7, std_cxx11::_8));
}
/**
typename Arg7, typename Arg8>
inline
internal::fun_encapsulator<RT,
- std_cxx1
x::tuple<Arg1, Arg2, Arg3,
+ std_cxx1
1::tuple<Arg1, Arg2, Arg3,
Arg4, Arg5, Arg6,
Arg7, Arg8>,8>
spawn (const C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,
typename Arg7, typename Arg8>
inline
internal::fun_encapsulator<RT,
- std_cxx1
x::tuple<Arg1, Arg2, Arg3,
+ std_cxx1
1::tuple<Arg1, Arg2, Arg3,
Arg4, Arg5, Arg6,
Arg7, Arg8>,8>
spawn (const C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,
Arg6,Arg7,Arg8) const)
{
return
- std_cxx1
x::function<typename internal::fun_ptr<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8> >::type>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::cref(c), std_cxx1x::_1, std_cxx1x::_2, std_cxx1x::_3, std_cxx1x::_4, std_cxx1x::_5, std_cxx1x::_6, std_cxx1x::_7, std_cxx1x::_8));
+ std_cxx1
1::function<typename internal::fun_ptr<RT,std_cxx11::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8> >::type>
+ (std_cxx11::bind(fun_ptr, std_cxx11::cref(c), std_cxx11::_1, std_cxx11::_2, std_cxx11::_3, std_cxx11::_4, std_cxx11::_5, std_cxx11::_6, std_cxx11::_7, std_cxx11::_8));
}
typename Arg4, typename Arg5, typename Arg6,
typename Arg7, typename Arg8, typename Arg9>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3,
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3,
Arg4, Arg5, Arg6,
Arg7, Arg8, Arg9>,9>
spawn (RT (*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,
typename Arg4, typename Arg5, typename Arg6,
typename Arg7, typename Arg8, typename Arg9>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3,
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3,
Arg4, Arg5, Arg6,
Arg7, Arg8, Arg9>,9>
spawn (RT (*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,
typename Arg4, typename Arg5, typename Arg6,
typename Arg7, typename Arg8, typename Arg9>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3,
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3,
Arg4, Arg5, Arg6,
Arg7, Arg8, Arg9>,9>
spawn (C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,
typename Arg4, typename Arg5, typename Arg6,
typename Arg7, typename Arg8, typename Arg9>
inline
- internal::fun_encapsulator<RT,std_cxx1
x::tuple<Arg1, Arg2, Arg3,
+ internal::fun_encapsulator<RT,std_cxx1
1::tuple<Arg1, Arg2, Arg3,
Arg4, Arg5, Arg6,
Arg7, Arg8, Arg9>,9>
spawn (C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,
Arg6,Arg7,Arg8,Arg9))
{
return
- std_cxx1
x::function<typename internal::fun_ptr<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9> >::type>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::ref(c), std_cxx1x::_1, std_cxx1x::_2, std_cxx1x::_3, std_cxx1x::_4, std_cxx1x::_5, std_cxx1x::_6, std_cxx1x::_7, std_cxx1x::_8, std_cxx1x::_9));
+ std_cxx1
1::function<typename internal::fun_ptr<RT,std_cxx11::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9> >::type>
+ (std_cxx11::bind(fun_ptr, std_cxx11::ref(c), std_cxx11::_1, std_cxx11::_2, std_cxx11::_3, std_cxx11::_4, std_cxx11::_5, std_cxx11::_6, std_cxx11::_7, std_cxx11::_8, std_cxx11::_9));
}
/**
typename Arg7, typename Arg8, typename Arg9>
inline
internal::fun_encapsulator<RT,
- std_cxx1
x::tuple<Arg1, Arg2, Arg3,
+ std_cxx1
1::tuple<Arg1, Arg2, Arg3,
Arg4, Arg5, Arg6,
Arg7, Arg8, Arg9>,9>
spawn (const C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,
typename Arg7, typename Arg8, typename Arg9>
inline
internal::fun_encapsulator<RT,
- std_cxx1
x::tuple<Arg1, Arg2, Arg3,
+ std_cxx1
1::tuple<Arg1, Arg2, Arg3,
Arg4, Arg5, Arg6,
Arg7, Arg8, Arg9>,9>
spawn (const C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,
Arg6,Arg7,Arg8,Arg9) const)
{
return
- std_cxx1
x::function<typename internal::fun_ptr<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9> >::type>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::cref(c), std_cxx1x::_1, std_cxx1x::_2, std_cxx1x::_3, std_cxx1x::_4, std_cxx1x::_5, std_cxx1x::_6, std_cxx1x::_7, std_cxx1x::_8, std_cxx1x::_9));
+ std_cxx1
1::function<typename internal::fun_ptr<RT,std_cxx11::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9> >::type>
+ (std_cxx11::bind(fun_ptr, std_cxx11::cref(c), std_cxx11::_1, std_cxx11::_2, std_cxx11::_3, std_cxx11::_4, std_cxx11::_5, std_cxx11::_6, std_cxx11::_7, std_cxx11::_8, std_cxx11::_9));
}
/**
* Overload of the new_thread function for
* objects that can be converted to
- * std_cxx1x::function<RT ()>, i.e. anything
+ * std_cxx11::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_cxx1x::function<RT ()> &function)
+ new_thread (const std_cxx11::function<RT ()> &function)
{
return Thread<RT>(function);
}
{
return
Thread<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::ref(c)));
+ (std_cxx11::bind(fun_ptr, std_cxx11::ref(c)));
}
{
return
Thread<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::cref(c)));
+ (std_cxx11::bind(fun_ptr, std_cxx11::cref(c)));
}
#endif
{
return
Thread<RT>
- (std_cxx1x::bind(fun_ptr,
+ (std_cxx11::bind(fun_ptr,
internal::maybe_make_ref<Arg1>::act(arg1)));
}
{
return
Thread<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::ref(c),
+ (std_cxx11::bind(fun_ptr, std_cxx11::ref(c),
internal::maybe_make_ref<Arg1>::act(arg1)));
}
{
return
Thread<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::cref(c),
+ (std_cxx11::bind(fun_ptr, std_cxx11::cref(c),
internal::maybe_make_ref<Arg1>::act(arg1)));
}
#endif
{
return
Thread<RT>
- (std_cxx1x::bind(fun_ptr,
+ (std_cxx11::bind(fun_ptr,
internal::maybe_make_ref<Arg1>::act(arg1),
internal::maybe_make_ref<Arg2>::act(arg2)));
}
{
return
Thread<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::ref(c),
+ (std_cxx11::bind(fun_ptr, std_cxx11::ref(c),
internal::maybe_make_ref<Arg1>::act(arg1),
internal::maybe_make_ref<Arg2>::act(arg2)));
}
{
return
Thread<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::cref(c),
+ (std_cxx11::bind(fun_ptr, std_cxx11::cref(c),
internal::maybe_make_ref<Arg1>::act(arg1),
internal::maybe_make_ref<Arg2>::act(arg2)));
}
{
return
Thread<RT>
- (std_cxx1x::bind(fun_ptr,
+ (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)));
{
return
Thread<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::ref(c),
+ (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)));
{
return
Thread<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::cref(c),
+ (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)));
{
return
Thread<RT>
- (std_cxx1x::bind(fun_ptr,
+ (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),
{
return
Thread<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::ref(c),
+ (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),
{
return
Thread<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::cref(c),
+ (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),
{
return
Thread<RT>
- (std_cxx1x::bind(fun_ptr,
+ (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),
{
return
Thread<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::ref(c),
+ (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),
{
return
Thread<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::cref(c),
+ (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),
{
return
Thread<RT>
- (std_cxx1x::bind(fun_ptr,
+ (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),
{
return
Thread<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::ref(c),
+ (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),
{
return
Thread<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::cref(c),
+ (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),
{
return
Thread<RT>
- (std_cxx1x::bind(fun_ptr,
+ (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),
{
return
Thread<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::ref(c),
+ (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),
{
return
Thread<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::cref(c),
+ (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),
{
return
Thread<RT>
- (std_cxx1x::bind(fun_ptr,
+ (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),
{
return
Thread<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::ref(c),
+ (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),
{
return
Thread<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::cref(c),
+ (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),
{
return
Thread<RT>
- (std_cxx1x::bind(fun_ptr,
+ (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),
{
return
Thread<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::ref(c),
+ (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),
{
return
Thread<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::cref(c),
+ (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),
* The function and its arguments
* that are to be run on the task.
*/
- std_cxx1x::function<RT ()> function;
+ std_cxx11::function<RT ()> function;
/**
* Variable holding the data the TBB
* Constructor. Take the function to
* be run on this task as argument.
*/
- TaskDescriptor (const std_cxx1x::function<RT ()> &function);
+ TaskDescriptor (const std_cxx11::function<RT ()> &function);
/**
* Default
template <typename RT>
inline
- TaskDescriptor<RT>::TaskDescriptor (const std_cxx1x::function<RT ()> &function)
+ TaskDescriptor<RT>::TaskDescriptor (const std_cxx11::function<RT ()> &function)
:
function (function),
task_is_done (false)
* slot reserved for this
* purpose.
*/
- TaskDescriptor (const std_cxx1x::function<RT ()> &function)
+ TaskDescriptor (const std_cxx11::function<RT ()> &function)
{
call (function, ret_val);
}
* given a function object to
* execute on the task.
*/
- Task (const std_cxx1x::function<RT ()> &function_object)
+ Task (const std_cxx11::function<RT ()> &function_object)
{
// create a task descriptor and tell it
// to queue itself up with the scheduling
// system
task_descriptor =
- std_cxx1x::shared_ptr<internal::TaskDescriptor<RT> >
+ std_cxx11::shared_ptr<internal::TaskDescriptor<RT> >
(new internal::TaskDescriptor<RT>(function_object));
task_descriptor->queue_task ();
}
void join () const
{
AssertThrow (task_descriptor !=
- std_cxx1x::shared_ptr<internal::TaskDescriptor<RT> >(),
+ std_cxx11::shared_ptr<internal::TaskDescriptor<RT> >(),
ExcNoTask());
task_descriptor->join ();
}
bool operator == (const Task &t)
{
AssertThrow (task_descriptor !=
- std_cxx1x::shared_ptr<internal::TaskDescriptor<RT> >(),
+ std_cxx11::shared_ptr<internal::TaskDescriptor<RT> >(),
ExcNoTask());
return task_descriptor == t.task_descriptor;
}
* long as there is at least one
* subscriber to it.
*/
- std_cxx1x::shared_ptr<internal::TaskDescriptor<RT> > task_descriptor;
+ std_cxx11::shared_ptr<internal::TaskDescriptor<RT> > task_descriptor;
};
/**
* Overload of the new_task function for
* objects that can be converted to
- * std_cxx1x::function<RT ()>, i.e. anything
+ * std_cxx11::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_cxx1x::function<RT ()> &function)
+ new_task (const std_cxx11::function<RT ()> &function)
{
return Task<RT>(function);
}
Task<RT>
new_task (RT (*fun_ptr)())
{
- return new_task<RT>(std_cxx1x::function<RT ()>(fun_ptr));
+ return new_task<RT>(std_cxx11::function<RT ()>(fun_ptr));
}
{
return
new_task<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::ref(c)));
+ (std_cxx11::bind(fun_ptr, std_cxx11::ref(c)));
}
#ifndef DEAL_II_CONST_MEMBER_DEDUCTION_BUG
{
return
new_task<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::cref(c)));
+ (std_cxx11::bind(fun_ptr, std_cxx11::cref(c)));
}
#endif
{
return
new_task<RT>
- (std_cxx1x::bind(fun_ptr,
+ (std_cxx11::bind(fun_ptr,
internal::maybe_make_ref<Arg1>::act(arg1)));
}
{
return
new_task<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::ref(c),
+ (std_cxx11::bind(fun_ptr, std_cxx11::ref(c),
internal::maybe_make_ref<Arg1>::act(arg1)));
}
{
return
new_task<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::cref(c),
+ (std_cxx11::bind(fun_ptr, std_cxx11::cref(c),
internal::maybe_make_ref<Arg1>::act(arg1)));
}
#endif
{
return
new_task<RT>
- (std_cxx1x::bind(fun_ptr,
+ (std_cxx11::bind(fun_ptr,
internal::maybe_make_ref<Arg1>::act(arg1),
internal::maybe_make_ref<Arg2>::act(arg2)));
}
{
return
new_task<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::ref(c),
+ (std_cxx11::bind(fun_ptr, std_cxx11::ref(c),
internal::maybe_make_ref<Arg1>::act(arg1),
internal::maybe_make_ref<Arg2>::act(arg2)));
}
{
return
new_task<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::cref(c),
+ (std_cxx11::bind(fun_ptr, std_cxx11::cref(c),
internal::maybe_make_ref<Arg1>::act(arg1),
internal::maybe_make_ref<Arg2>::act(arg2)));
}
{
return
new_task<RT>
- (std_cxx1x::bind(fun_ptr,
+ (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)));
{
return
new_task<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::ref(c),
+ (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)));
{
return
new_task<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::cref(c),
+ (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)));
{
return
new_task<RT>
- (std_cxx1x::bind(fun_ptr,
+ (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),
{
return
new_task<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::ref(c),
+ (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),
{
return
new_task<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::cref(c),
+ (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),
{
return
new_task<RT>
- (std_cxx1x::bind(fun_ptr,
+ (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),
{
return
new_task<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::ref(c),
+ (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),
{
return
new_task<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::cref(c),
+ (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),
{
return
new_task<RT>
- (std_cxx1x::bind(fun_ptr,
+ (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),
{
return
new_task<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::ref(c),
+ (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),
{
return
new_task<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::cref(c),
+ (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),
{
return
new_task<RT>
- (std_cxx1x::bind(fun_ptr,
+ (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),
{
return
new_task<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::ref(c),
+ (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),
{
return
new_task<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::cref(c),
+ (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),
{
return
new_task<RT>
- (std_cxx1x::bind(fun_ptr,
+ (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),
{
return
new_task<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::ref(c),
+ (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),
{
return
new_task<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::cref(c),
+ (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),
{
return
new_task<RT>
- (std_cxx1x::bind(fun_ptr,
+ (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),
{
return
new_task<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::ref(c),
+ (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),
{
return
new_task<RT>
- (std_cxx1x::bind(fun_ptr, std_cxx1x::cref(c),
+ (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),
#include <deal.II/base/config.h>
-#include <deal.II/base/std_cxx1x/function.h>
+#include <deal.II/base/std_cxx11/function.h>
#include <vector>
* time step.
*/
virtual double evolve_one_time_step(
- std::vector<std_cxx1x::function<VECTOR (const double, const VECTOR &)> > &F,
- std::vector<std_cxx1x::function<VECTOR (const double, const double, const VECTOR &)> > &J_inverse,
+ std::vector<std_cxx11::function<VECTOR (const double, const VECTOR &)> > &F,
+ std::vector<std_cxx11::function<VECTOR (const double, const double, const VECTOR &)> > &J_inverse,
double t,
double delta_t,
VECTOR &y) = 0;
* only contain one element.
*/
double evolve_one_time_step(
- std::vector<std_cxx1x::function<VECTOR (const double, const VECTOR &)> > &F,
- std::vector<std_cxx1x::function<VECTOR (const double, const double, const VECTOR &)> > &J_inverse,
+ std::vector<std_cxx11::function<VECTOR (const double, const VECTOR &)> > &F,
+ std::vector<std_cxx11::function<VECTOR (const double, const double, const VECTOR &)> > &J_inverse,
double t,
double delta_t,
VECTOR &y);
* evolve_one_time_step returns the time at the end of the time step.
*/
virtual double evolve_one_time_step(
- std_cxx1x::function<VECTOR (const double, const VECTOR &)> f,
- std_cxx1x::function<VECTOR (const double, const double, const VECTOR &)> id_minus_tau_J_inverse,
+ std_cxx11::function<VECTOR (const double, const VECTOR &)> f,
+ std_cxx11::function<VECTOR (const double, const double, const VECTOR &)> id_minus_tau_J_inverse,
double t,
double delta_t,
VECTOR &y) = 0;
* evolve_one_time_step returns the time at the end of the time step.
*/
double evolve_one_time_step(
- std_cxx1x::function<VECTOR (const double, const VECTOR &)> f,
- std_cxx1x::function<VECTOR (const double, const double, const VECTOR &)> id_minus_tau_J_inverse,
+ std_cxx11::function<VECTOR (const double, const VECTOR &)> f,
+ std_cxx11::function<VECTOR (const double, const double, const VECTOR &)> id_minus_tau_J_inverse,
double t,
double delta_t,
VECTOR &y);
* explicit methods. evolve_one_time_step returns the time at the end of the
* time step.
*/
- double evolve_one_time_step(std_cxx1x::function<VECTOR (const double, const VECTOR &)> f,
+ double evolve_one_time_step(std_cxx11::function<VECTOR (const double, const VECTOR &)> f,
double t,
double delta_t,
VECTOR &y);
/**
* Compute the different stages needed.
*/
- void compute_stages(std_cxx1x::function<VECTOR (const double, const VECTOR &)> f,
+ void compute_stages(std_cxx11::function<VECTOR (const double, const VECTOR &)> f,
const double t,
const double delta_t,
const VECTOR &y,
* evolve_one_time_step returns the time at the end of the time step.
*/
double evolve_one_time_step(
- std_cxx1x::function<VECTOR (const double, const VECTOR &)> f,
- std_cxx1x::function<VECTOR (const double, const double, const VECTOR &)> id_minus_tau_J_inverse,
+ std_cxx11::function<VECTOR (const double, const VECTOR &)> f,
+ std_cxx11::function<VECTOR (const double, const double, const VECTOR &)> id_minus_tau_J_inverse,
double t,
double delta_t,
VECTOR &y);
* Compute the different stages needed.
*/
void compute_stages(
- std_cxx1x::function<VECTOR (const double, const VECTOR &)> f,
- std_cxx1x::function<VECTOR (const double, const double, const VECTOR &)> id_minus_tau_J_inverse,
+ std_cxx11::function<VECTOR (const double, const VECTOR &)> f,
+ std_cxx11::function<VECTOR (const double, const double, const VECTOR &)> id_minus_tau_J_inverse,
double t,
double delta_t,
VECTOR &y,
/**
* Newton solver used for the implicit stages.
*/
- void newton_solve(std_cxx1x::function<void (const VECTOR &,VECTOR &)> get_residual,
- std_cxx1x::function<VECTOR (const VECTOR &)> id_minus_tau_J_inverse,
+ void newton_solve(std_cxx11::function<void (const VECTOR &,VECTOR &)> get_residual,
+ std_cxx11::function<VECTOR (const VECTOR &)> id_minus_tau_J_inverse,
VECTOR &y);
/**
* Compute the residual needed by the Newton solver.
*/
- void compute_residual(std_cxx1x::function<VECTOR (const double, const VECTOR &)> f,
+ void compute_residual(std_cxx11::function<VECTOR (const double, const VECTOR &)> f,
double t,
double delta_t,
const VECTOR &old_y,
* evolve_one_time_step returns the time at the end of the time step.
*/
double evolve_one_time_step(
- std_cxx1x::function<VECTOR (const double, const VECTOR &)> f,
- std_cxx1x::function<VECTOR (const double, const double, const VECTOR &)> id_minus_tau_J_inverse,
+ std_cxx11::function<VECTOR (const double, const VECTOR &)> f,
+ std_cxx11::function<VECTOR (const double, const double, const VECTOR &)> id_minus_tau_J_inverse,
double t,
double delta_t,
VECTOR &y);
* explicit methods. evolve_one_time_step returns the time at the end of the
* time step.
*/
- double evolve_one_time_step(std_cxx1x::function<VECTOR (const double, const VECTOR &)> f,
+ double evolve_one_time_step(std_cxx11::function<VECTOR (const double, const VECTOR &)> f,
double t,
double delta_t,
VECTOR &y);
/**
* Compute the different stages needed.
*/
- void compute_stages(std_cxx1x::function<VECTOR (const double, const VECTOR &)> f,
+ void compute_stages(std_cxx11::function<VECTOR (const double, const VECTOR &)> f,
const double t,
const double delta_t,
const VECTOR &y,
#ifndef __deal2__time_stepping_templates_h
#define __deal2__time_stepping_templates_h
-#include <deal.II/base/std_cxx1x/bind.h>
+#include <deal.II/base/std_cxx11/bind.h>
#include <deal.II/base/exceptions.h>
#include <deal.II/base/time_stepping.h>
template <typename VECTOR>
double RungeKutta<VECTOR>::evolve_one_time_step(
- std::vector<std_cxx1x::function<VECTOR (const double, const VECTOR &)> > &F,
- std::vector<std_cxx1x::function<VECTOR (const double, const double, const VECTOR &)> > &J_inverse,
+ std::vector<std_cxx11::function<VECTOR (const double, const VECTOR &)> > &F,
+ std::vector<std_cxx11::function<VECTOR (const double, const double, const VECTOR &)> > &J_inverse,
+
double t,
double delta_t,
VECTOR &y)
template <typename VECTOR>
double ExplicitRungeKutta<VECTOR>::evolve_one_time_step(
- std_cxx1x::function<VECTOR (const double, const VECTOR &)> f,
- std_cxx1x::function<VECTOR (const double, const double, const VECTOR &)> id_minus_tau_J_inverse,
+ std_cxx11::function<VECTOR (const double, const VECTOR &)> f,
+ std_cxx11::function<VECTOR (const double, const double, const VECTOR &)> id_minus_tau_J_inverse,
double t,
double delta_t,
VECTOR &y)
template <typename VECTOR>
double ExplicitRungeKutta<VECTOR>::evolve_one_time_step(
- std_cxx1x::function<VECTOR (const double, const VECTOR &)> f,
+ std_cxx11::function<VECTOR (const double, const VECTOR &)> f,
double t,
double delta_t,
VECTOR &y)
template <typename VECTOR>
void ExplicitRungeKutta<VECTOR>::compute_stages(
- std_cxx1x::function<VECTOR (const double, const VECTOR &)> f,
+ std_cxx11::function<VECTOR (const double, const VECTOR &)> f,
const double t,
const double delta_t,
const VECTOR &y,
template <typename VECTOR>
double ImplicitRungeKutta<VECTOR>::evolve_one_time_step(
- std_cxx1x::function<VECTOR (const double, const VECTOR &)> f,
- std_cxx1x::function<VECTOR (const double, const double, const VECTOR &)> id_minus_tau_J_inverse,
+ std_cxx11::function<VECTOR (const double, const VECTOR &)> f,
+ std_cxx11::function<VECTOR (const double, const double, const VECTOR &)> id_minus_tau_J_inverse,
double t,
double delta_t,
VECTOR &y)
template <typename VECTOR>
void ImplicitRungeKutta<VECTOR>::compute_stages(
- std_cxx1x::function<VECTOR (const double, const VECTOR &)> f,
- std_cxx1x::function<VECTOR (const double, const double, const VECTOR &)> id_minus_tau_J_inverse,
+ std_cxx11::function<VECTOR (const double, const VECTOR &)> f,
+ std_cxx11::function<VECTOR (const double, const double, const VECTOR &)> id_minus_tau_J_inverse,
double t,
double delta_t,
VECTOR &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_cxx1x::bind(&ImplicitRungeKutta<VECTOR>::compute_residual,this,f,new_t,new_delta_t,
- std_cxx1x::cref(old_y),std_cxx1x::_1,std_cxx1x::ref(f_stages[i]),std_cxx1x::_2),
- std_cxx1x::bind(id_minus_tau_J_inverse,new_t,new_delta_t,std_cxx1x::_1),y);
+ newton_solve(std_cxx11::bind(&ImplicitRungeKutta<VECTOR>::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);
}
}
template <typename VECTOR>
void ImplicitRungeKutta<VECTOR>::newton_solve(
- std_cxx1x::function<void (const VECTOR &,VECTOR &)> get_residual,
- std_cxx1x::function<VECTOR (const VECTOR &)> id_minus_tau_J_inverse,
+ std_cxx11::function<void (const VECTOR &,VECTOR &)> get_residual,
+ std_cxx11::function<VECTOR (const VECTOR &)> id_minus_tau_J_inverse,
VECTOR &y)
{
VECTOR residual(y);
template <typename VECTOR>
void ImplicitRungeKutta<VECTOR>::compute_residual(
- std_cxx1x::function<VECTOR (const double, const VECTOR &)> f,
+ std_cxx11::function<VECTOR (const double, const VECTOR &)> f,
double t,
double delta_t,
const VECTOR &old_y,
template <typename VECTOR>
double EmbeddedExplicitRungeKutta<VECTOR>::evolve_one_time_step(
- std_cxx1x::function<VECTOR (const double, const VECTOR &)> f,
- std_cxx1x::function<VECTOR (const double, const double, const VECTOR &)> id_minus_tau_J_inverse,
+ std_cxx11::function<VECTOR (const double, const VECTOR &)> f,
+ std_cxx11::function<VECTOR (const double, const double, const VECTOR &)> id_minus_tau_J_inverse,
double t,
double delta_t,
VECTOR &y)
template <typename VECTOR>
double EmbeddedExplicitRungeKutta<VECTOR>::evolve_one_time_step(
- std_cxx1x::function<VECTOR (const double, const VECTOR &)> f,
+ std_cxx11::function<VECTOR (const double, const VECTOR &)> f,
double t, double delta_t, VECTOR &y)
{
bool done = false;
template <typename VECTOR>
void EmbeddedExplicitRungeKutta<VECTOR>::compute_stages(
- std_cxx1x::function<VECTOR (const double, const VECTOR &)> f,
+ std_cxx11::function<VECTOR (const double, const VECTOR &)> f,
const double t,
const double delta_t,
const VECTOR &y,
// ---------------------------------------------------------------------
// $Id$
//
-// Copyright (C) 2008 - 2013 by the deal.II authors
+// Copyright (C) 2008 - 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
#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_cxx1x/function.h>
-#include <deal.II/base/std_cxx1x/bind.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>
namespace internal
{
-//TODO: The following classes all use std_cxx1x::shared_ptr, but the
+//TODO: The following classes all use std_cxx11::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_cxx1x::shared_ptr<ScratchData> scratch_data;
+ std_cxx11::shared_ptr<ScratchData> scratch_data;
bool currently_in_use;
/**
* function that will do the
* assembly.
*/
- Worker (const std_cxx1x::function<void (const Iterator &,
+ Worker (const std_cxx11::function<void (const Iterator &,
ScratchData &,
CopyData &)> &worker,
bool copier_exist=true)
* that does the assembling
* on the sequence of cells.
*/
- const std_cxx1x::function<void (const Iterator &,
+ const std_cxx11::function<void (const Iterator &,
ScratchData &,
CopyData &)> worker;
* the global matrix or
* similar.
*/
- Copier (const std_cxx1x::function<void (const CopyData &)> &copier)
+ Copier (const std_cxx11::function<void (const CopyData &)> &copier)
:
tbb::filter (/*is_serial=*/true),
copier (copier)
/**
* Pointer to the function that does the copying of data.
*/
- const std_cxx1x::function<void (const CopyData &)> copier;
+ const std_cxx11::function<void (const CopyData &)> copier;
};
}
*/
struct ScratchAndCopyDataObjects
{
- std_cxx1x::shared_ptr<ScratchData> scratch_data;
- std_cxx1x::shared_ptr<CopyData> copy_data;
+ std_cxx11::shared_ptr<ScratchData> scratch_data;
+ std_cxx11::shared_ptr<CopyData> copy_data;
bool currently_in_use;
/**
* function that will do the
* assembly.
*/
- WorkerAndCopier (const std_cxx1x::function<void (const Iterator &,
+ WorkerAndCopier (const std_cxx11::function<void (const Iterator &,
ScratchData &,
CopyData &)> &worker,
- const std_cxx1x::function<void (const CopyData &)> &copier)
+ const std_cxx11::function<void (const CopyData &)> &copier)
:
tbb::filter (/* is_serial= */ false),
worker (worker),
* that does the assembling
* on the sequence of cells.
*/
- const std_cxx1x::function<void (const Iterator &,
+ const std_cxx11::function<void (const Iterator &,
ScratchData &,
CopyData &)> worker;
* Pointer to the function that does the copying from
* local contribution to global object.
*/
- const std_cxx1x::function<void (const CopyData &)> copier;
+ const std_cxx11::function<void (const CopyData &)> copier;
};
}
/**
* Constructor.
*/
- Worker (const std_cxx1x::function<void (const Iterator &,
+ Worker (const std_cxx11::function<void (const Iterator &,
ScratchData &,
CopyData &)> &worker,
const ScratchData &sample_scratch_data,
* that does the assembling
* on the sequence of cells.
*/
- const std_cxx1x::function<void (const Iterator &,
+ const std_cxx11::function<void (const Iterator &,
ScratchData &,
CopyData &)> worker;
{
// 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_cxx1x::function<void (const Iterator &,
+ if (static_cast<const std_cxx11::function<void (const Iterator &,
ScratchData &,
CopyData &)>& >(worker))
worker (i, scratch_data, copy_data);
- if (static_cast<const std_cxx1x::function<void (const CopyData &)>& >
+ if (static_cast<const std_cxx11::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_cxx1x::function<void (const CopyData &)>& >(copier))
+ if (static_cast<const std_cxx11::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_cxx1x::function<void (const Iterator &,
+ if (static_cast<const std_cxx11::function<void (const Iterator &,
ScratchData &,
CopyData &)>& >(worker))
worker (*p, scratch_data, copy_data);
- if (static_cast<const std_cxx1x::function<void (const CopyData &)>& >(copier))
+ if (static_cast<const std_cxx11::function<void (const CopyData &)>& >(copier))
copier (copy_data);
}
}
for (unsigned int color=0; color<colored_iterators.size(); ++color)
if (colored_iterators[color].size() > 0)
{
- if (static_cast<const std_cxx1x::function<void (const CopyData &)>& >(copier))
+ if (static_cast<const std_cxx11::function<void (const CopyData &)>& >(copier))
{
// there is a copier function, so we have to go with
// the full three-stage design of the pipeline
else
{
// no copier function, we can implement things as a parallel for
- Assert (static_cast<const std_cxx1x::function<void (const Iterator &,
+ Assert (static_cast<const std_cxx11::function<void (const Iterator &,
ScratchData &,
CopyData &)>& >(worker),
ExcMessage ("It makes no sense to call this function with "
(colored_iterators[color].begin(),
colored_iterators[color].end(),
/*grain_size=*/chunk_size),
- std_cxx1x::bind (&ParallelForWorker::operator(),
- std_cxx1x::ref(parallel_for_worker),
- std_cxx1x::_1),
+ std_cxx11::bind (&ParallelForWorker::operator(),
+ std_cxx11::ref(parallel_for_worker),
+ std_cxx11::_1),
tbb::auto_partitioner());
}
}
{
// forward to the other function
run (begin, end,
- std_cxx1x::bind (worker,
- std_cxx1x::ref (main_object),
- std_cxx1x::_1, std_cxx1x::_2, std_cxx1x::_3),
- std_cxx1x::bind (copier,
- std_cxx1x::ref (main_object),
- std_cxx1x::_1),
+ 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),
sample_scratch_data,
sample_copy_data,
queue_length,
#include <deal.II/base/template_constraints.h>
#include <deal.II/grid/tria.h>
-#include <deal.II/base/std_cxx1x/function.h>
-#include <deal.II/base/std_cxx1x/tuple.h>
+#include <deal.II/base/std_cxx11/function.h>
+#include <deal.II/base/std_cxx11/tuple.h>
#include <set>
#include <vector>
* into the function. C++ provides a nice mechanism for this that is best
* explained using an example:
* @code
- * #include <deal.II/base/std_cxx1x/bind.h>
+ * #include <deal.II/base/std_cxx11/bind.h>
*
* template <int dim>
* void set_boundary_indicators (parallel::distributed::Triangulation<dim> &triangulation)
* ... create the coarse mesh ...
*
* coarse_grid.signals.post_refinement.connect
- * (std_cxx1x::bind (&set_boundary_indicators<dim>,
- * std_cxx1x::ref(coarse_grid)));
+ * (std_cxx11::bind (&set_boundary_indicators<dim>,
+ * std_cxx11::ref(coarse_grid)));
*
* }
* @endcode
*
- * What the call to <code>std_cxx1x::bind</code> does is to produce an object that
+ * What the call to <code>std_cxx11::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 coarse grid triangulation. After each
* function has been declared as a (non-static, but possibly private) member
* function of the <code>MyClass</code> class, then the following will work:
* @code
- * #include <deal.II/base/std_cxx1x/bind.h>
+ * #include <deal.II/base/std_cxx11/bind.h>
*
* template <int dim>
* void
* ... create the coarse mesh ...
*
* coarse_grid.signals.post_refinement.connect
- * (std_cxx1x::bind (&MyGeometry<dim>::set_boundary_indicators,
- * std_cxx1x::cref(*this),
- * std_cxx1x::ref(coarse_grid)));
+ * (std_cxx11::bind (&MyGeometry<dim>::set_boundary_indicators,
+ * std_cxx11::cref(*this),
+ * std_cxx11::ref(coarse_grid)));
* }
* @endcode
* Here, like any other member function, <code>set_boundary_indicators</code>
*/
unsigned int
register_data_attach (const std::size_t size,
- const std_cxx1x::function<void (const cell_iterator &,
+ const std_cxx11::function<void (const cell_iterator &,
const CellStatus,
void *)> &pack_callback);
*/
void
notify_ready_to_unpack (const unsigned int offset,
- const std_cxx1x::function<void (const cell_iterator &,
+ const std_cxx11::function<void (const cell_iterator &,
const CellStatus,
const void *)> &unpack_callback);
*/
unsigned int n_attached_deserialize;
- typedef std_cxx1x::function<
+ typedef std_cxx11::function<
void(typename Triangulation<dim,spacedim>::cell_iterator, CellStatus, void *)
> pack_callback_t;
#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_cxx1x/shared_ptr.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>
* of freedom should be distributed and
* renumbered.
*/
- std_cxx1x::shared_ptr<dealii::internal::DoFHandler::Policy::PolicyBase<dim,spacedim> > policy;
+ std_cxx11::shared_ptr<dealii::internal::DoFHandler::Policy::PolicyBase<dim,spacedim> > policy;
/**
* A structure that contains all
* 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_cxx1x::shared_ptr<const FiniteElement<dim,spacedim> >,
+ std::vector<std::pair<std_cxx11::shared_ptr<const FiniteElement<dim,spacedim> >,
unsigned int> >
base_elements;
#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_cxx1x/function.h>
+#include <deal.II/base/std_cxx11/function.h>
#include <deal.II/grid/tria_iterator_selector.h>
#include <deal.II/grid/tria_faces.h>
#include <deal.II/grid/tria_levels.h>
* // mesh refinement
* previous_cell = current_cell;
* previous_cell.get_tria().signals.post_refinement
- * .connect (std_cxx1x::bind (&FEValues<dim>::invalidate_previous_cell,
- * std_cxx1x::ref (*this)));
+ * .connect (std_cxx11::bind (&FEValues<dim>::invalidate_previous_cell,
+ * std_cxx11::ref (*this)));
* }
* else
* previous_cell = current_cell;
/**
* Point generator for the intermediate points on a boundary.
*/
- mutable std::vector<std_cxx1x::shared_ptr<QGaussLobatto<1> > > points;
+ mutable std::vector<std_cxx11::shared_ptr<QGaussLobatto<1> > > points;
/**
* Mutex for protecting the points array.
#define __deal2__fe_collection_h
#include <deal.II/base/config.h>
-#include <deal.II/base/std_cxx1x/shared_ptr.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>
* Array of pointers to the finite
* elements stored by this collection.
*/
- std::vector<std_cxx1x::shared_ptr<const FiniteElement<dim,spacedim> > > finite_elements;
+ std::vector<std_cxx11::shared_ptr<const FiniteElement<dim,spacedim> > > finite_elements;
};
#include <deal.II/fe/fe_values.h>
#include <map>
-#include <deal.II/base/std_cxx1x/shared_ptr.h>
+#include <deal.II/base/std_cxx11/shared_ptr.h>
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_cxx1x::shared_ptr<FEValues> > fe_values_table;
+ dealii::Table<3,std_cxx11::shared_ptr<FEValues> > 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_cxx1x/shared_ptr.h>
+#include <deal.II/base/std_cxx11/shared_ptr.h>
DEAL_II_NAMESPACE_OPEN
* pointers to the different Mapping
* objects.
*/
- std::vector<std_cxx1x::shared_ptr<const Mapping<dim,spacedim> > > mappings;
+ std::vector<std_cxx11::shared_ptr<const Mapping<dim,spacedim> > > mappings;
};
#include <deal.II/fe/fe.h>
#include <vector>
-#include <deal.II/base/std_cxx1x/shared_ptr.h>
+#include <deal.II/base/std_cxx11/shared_ptr.h>
DEAL_II_NAMESPACE_OPEN
* pointers to the different quadrature
* objects.
*/
- std::vector<std_cxx1x::shared_ptr<const Quadrature<dim> > > quadratures;
+ std::vector<std_cxx11::shared_ptr<const Quadrature<dim> > > quadratures;
};
QCollection<dim>::QCollection (const Quadrature<dim> &quadrature)
{
quadratures
- .push_back (std_cxx1x::shared_ptr<const Quadrature<dim> >(new Quadrature<dim>(quadrature)));
+ .push_back (std_cxx11::shared_ptr<const Quadrature<dim> >(new Quadrature<dim>(quadrature)));
}
QCollection<dim>::push_back (const Quadrature<dim> &new_quadrature)
{
quadratures
- .push_back (std_cxx1x::shared_ptr<const Quadrature<dim> >(new Quadrature<dim>(new_quadrature)));
+ .push_back (std_cxx11::shared_ptr<const Quadrature<dim> >(new Quadrature<dim>(new_quadrature)));
}
} // namespace hp
(matrix_size+m()) / m();
if (matrix_size>grain_size)
parallel::apply_to_subranges (0U, matrix_size,
- std_cxx1x::bind(&internal::ChunkSparseMatrix::template
+ std_cxx11::bind(&internal::ChunkSparseMatrix::template
zero_subrange<number>,
- std_cxx1x::_1, std_cxx1x::_2,
+ std_cxx11::_1, std_cxx11::_2,
val),
grain_size);
else if (matrix_size > 0)
Assert (!PointerComparison::equal(&src, &dst), ExcSourceEqualsDestination());
parallel::apply_to_subranges (0U, cols->sparsity_pattern.n_rows(),
- std_cxx1x::bind (&internal::ChunkSparseMatrix::vmult_add_on_subrange
+ std_cxx11::bind (&internal::ChunkSparseMatrix::vmult_add_on_subrange
<number,InVector,OutVector>,
- std_cxx1x::cref(*cols),
- std_cxx1x::_1, std_cxx1x::_2,
+ std_cxx11::cref(*cols),
+ std_cxx11::_1, std_cxx11::_2,
val,
cols->sparsity_pattern.rowstart,
cols->sparsity_pattern.colnums,
- std_cxx1x::cref(src),
- std_cxx1x::ref(dst)),
+ std_cxx11::cref(src),
+ std_cxx11::ref(dst)),
internal::SparseMatrix::minimum_parallel_grain_size/cols->chunk_size+1);
}
* pattern used for this
* matrix.
*/
- std_cxx1
x::shared_ptr<PointerMatrixBase<VECTOR> > matrix;
+ std_cxx1
1::shared_ptr<PointerMatrixBase<VECTOR> > matrix;
/**
* Sorted list of pairs denoting
/**
* The matrix in use.
*/
- std_cxx1
x::shared_ptr<PointerMatrixBase<VECTOR> > matrix;
+ std_cxx1
1::shared_ptr<PointerMatrixBase<VECTOR> > matrix;
/**
* The preconditioner to use.
*/
- std_cxx1
x::shared_ptr<PointerMatrixBase<VECTOR> > preconditioner;
+ std_cxx1
1::shared_ptr<PointerMatrixBase<VECTOR> > preconditioner;
};
{
// dummy variable
VECTOR *v = 0;
- matrix = std_cxx1
x::shared_ptr<PointerMatrixBase<VECTOR> > (new_pointer_matrix_base(m, *v));
- preconditioner = std_cxx1
x::shared_ptr<PointerMatrixBase<VECTOR> > (new_pointer_matrix_base(p, *v));
+ matrix = std_cxx1
1::shared_ptr<PointerMatrixBase<VECTOR> > (new_pointer_matrix_base(m, *v));
+ preconditioner = std_cxx1
1::shared_ptr<PointerMatrixBase<VECTOR> > (new_pointer_matrix_base(p, *v));
}
#include <deal.II/lac/lapack_support.h>
#include <deal.II/lac/vector_memory.h>
-#include <deal.II/base/std_cxx1x/shared_ptr.h>
+#include <deal.II/base/std_cxx11/shared_ptr.h>
#include <vector>
#include <complex>
* The matrix <i>U</i> in the singular value decomposition
* <i>USV<sup>T</sup></i>.
*/
- std_cxx1x::shared_ptr<LAPACKFullMatrix<number> > svd_u;
+ std_cxx11::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_cxx1x::shared_ptr<LAPACKFullMatrix<number> > svd_vt;
+ std_cxx11::shared_ptr<LAPACKFullMatrix<number> > svd_vt;
};
#include <deal.II/base/config.h>
#include <deal.II/base/named_data.h>
#include <deal.II/base/smartpointer.h>
-#include <deal.II/base/std_cxx1x/shared_ptr.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>
template <class MATRIX>
class MatrixBlockVector
:
- private NamedData<std_cxx1x::shared_ptr<MatrixBlock<MATRIX> > >
+ private NamedData<std_cxx11::shared_ptr<MatrixBlock<MATRIX> > >
{
public:
/**
/**
* import functions from private base class
*/
- using NamedData<std_cxx1x::shared_ptr<value_type> >::subscribe;
- using NamedData<std_cxx1x::shared_ptr<value_type> >::unsubscribe;
- using NamedData<std_cxx1x::shared_ptr<value_type> >::size;
- using NamedData<std_cxx1x::shared_ptr<value_type> >::name;
+ using NamedData<std_cxx11::shared_ptr<value_type> >::subscribe;
+ using NamedData<std_cxx11::shared_ptr<value_type> >::unsubscribe;
+ using NamedData<std_cxx11::shared_ptr<value_type> >::size;
+ using NamedData<std_cxx11::shared_ptr<value_type> >::name;
};
size_type row, size_type column,
const std::string &name)
{
- std_cxx1x::shared_ptr<value_type> p(new value_type(row, column));
- NamedData<std_cxx1x::shared_ptr<value_type> >::add(p, name);
+ std_cxx11::shared_ptr<value_type> p(new value_type(row, column));
+ NamedData<std_cxx11::shared_ptr<value_type> >::add(p, name);
}
* partitioner data only once and share it between several vectors with
* the same layout.
*/
- Vector (const std_cxx1x::shared_ptr<const Utilities::MPI::Partitioner> &partitioner);
+ Vector (const std_cxx11::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_cxx1x::shared_ptr<const Utilities::MPI::Partitioner> &partitioner);
+ void reinit (const std_cxx11::shared_ptr<const Utilities::MPI::Partitioner> &partitioner);
/**
* Swap the contents of this vector and the other vector @p v. One could
* information can be shared between several vectors that have the same
* partitioning.
*/
- std_cxx1x::shared_ptr<const Utilities::MPI::Partitioner> partitioner;
+ std_cxx11::shared_ptr<const Utilities::MPI::Partitioner> partitioner;
/**
* The size that is currently allocated in the val array.
template <typename Number>
inline
Vector<Number>::
- Vector (const std_cxx1x::shared_ptr<const Utilities::MPI::Partitioner> &partitioner)
+ Vector (const std_cxx11::shared_ptr<const Utilities::MPI::Partitioner> &partitioner)
:
allocated_size (0),
val (0),
const MPI_Comm communicator)
{
// set up parallel partitioner with index sets and communicator
- std_cxx1x::shared_ptr<const Utilities::MPI::Partitioner> new_partitioner
+ std_cxx11::shared_ptr<const Utilities::MPI::Partitioner> new_partitioner
(new Utilities::MPI::Partitioner (locally_owned_indices,
ghost_indices, communicator));
reinit (new_partitioner);
{
// set up parallel partitioner with index sets and communicator
IndexSet ghost_indices(locally_owned_indices.size());
- std_cxx1x::shared_ptr<const Utilities::MPI::Partitioner> new_partitioner
+ std_cxx11::shared_ptr<const Utilities::MPI::Partitioner> new_partitioner
(new Utilities::MPI::Partitioner (locally_owned_indices,
ghost_indices, communicator));
reinit (new_partitioner);
template <typename Number>
void
- Vector<Number>::reinit (const std_cxx1x::shared_ptr<const Utilities::MPI::Partitioner> &partitioner_in)
+ Vector<Number>::reinit (const std_cxx11::shared_ptr<const Utilities::MPI::Partitioner> &partitioner_in)
{
clear_mpi_requests();
partitioner = partitioner_in;
# include <deal.II/lac/vector.h>
# include <petscmat.h>
-# include <deal.II/base/std_cxx1x/shared_ptr.h>
+# include <deal.II/base/std_cxx11/shared_ptr.h>
# include <vector>
# include <cmath>
* accessor can access this data
* if necessary.
*/
- std_cxx1x::shared_ptr<const std::vector<size_type> > colnum_cache;
+ std_cxx11::shared_ptr<const std::vector<size_type> > colnum_cache;
/**
* Similar cache for the values
* of this row.
*/
- std_cxx1
x::shared_ptr<const std::vector<PetscScalar> > value_cache;
+ std_cxx1
1::shared_ptr<const std::vector<PetscScalar> > value_cache;
/**
* Discard the old row caches
# include <deal.II/lac/exceptions.h>
# include <deal.II/lac/solver_control.h>
-# include <deal.II/base/std_cxx1x/shared_ptr.h>
+# include <deal.II/base/std_cxx11/shared_ptr.h>
# include <petscksp.h>
* the main solver routine if
* necessary.
*/
- std_cxx1x::shared_ptr<SolverData> solver_data;
+ std_cxx11::shared_ptr<SolverData> solver_data;
};
PC pc;
};
- std_cxx1x::shared_ptr<SolverDataMUMPS> solver_data;
+ std_cxx11::shared_ptr<SolverDataMUMPS> solver_data;
/**
* Flag specifies whether matrix
#ifdef DEAL_II_WITH_SLEPC
-# include <deal.II/base/std_cxx1x/shared_ptr.h>
+# 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>
/**
* Pointer to the <code>SolverData</code> object.
*/
- std_cxx1x::shared_ptr<SolverData> solver_data;
+ std_cxx11::shared_ptr<SolverData> solver_data;
};
/**
#ifdef DEAL_II_WITH_SLEPC
-# include <deal.II/base/std_cxx1x/shared_ptr.h>
+# include <deal.II/base/std_cxx11/shared_ptr.h>
# include <deal.II/lac/exceptions.h>
# include <petscksp.h>
ST st;
};
- std_cxx1x::shared_ptr<TransformationData> transformation_data;
+ std_cxx11::shared_ptr<TransformationData> transformation_data;
};
/**
#include <cmath>
#include <vector>
#include <numeric>
-#include <deal.II/base/std_cxx1x/bind.h>
+#include <deal.II/base/std_cxx11/bind.h>
(cols->n_nonzero_elements()+m()) / m();
if (matrix_size>grain_size)
parallel::apply_to_subranges (0U, matrix_size,
- std_cxx1x::bind(&internal::SparseMatrix::template
+ std_cxx11::bind(&internal::SparseMatrix::template
zero_subrange<number>,
- std_cxx1x::_1, std_cxx1x::_2,
+ std_cxx11::_1, std_cxx11::_2,
val),
grain_size);
else if (matrix_size > 0)
Assert (!PointerComparison::equal(&src, &dst), ExcSourceEqualsDestination());
parallel::apply_to_subranges (0U, m(),
- std_cxx1x::bind (&internal::SparseMatrix::vmult_on_subrange
+ std_cxx11::bind (&internal::SparseMatrix::vmult_on_subrange
<number,InVector,OutVector>,
- std_cxx1x::_1, std_cxx1x::_2,
+ std_cxx11::_1, std_cxx11::_2,
val,
cols->rowstart,
cols->colnums,
- std_cxx1x::cref(src),
- std_cxx1x::ref(dst),
+ std_cxx11::cref(src),
+ std_cxx11::ref(dst),
false),
internal::SparseMatrix::minimum_parallel_grain_size);
}
Assert (!PointerComparison::equal(&src, &dst), ExcSourceEqualsDestination());
parallel::apply_to_subranges (0U, m(),
- std_cxx1x::bind (&internal::SparseMatrix::vmult_on_subrange
+ std_cxx11::bind (&internal::SparseMatrix::vmult_on_subrange
<number,InVector,OutVector>,
- std_cxx1x::_1, std_cxx1x::_2,
+ std_cxx11::_1, std_cxx11::_2,
val,
cols->rowstart,
cols->colnums,
- std_cxx1x::cref(src),
- std_cxx1x::ref(dst),
+ std_cxx11::cref(src),
+ std_cxx11::ref(dst),
true),
internal::SparseMatrix::minimum_parallel_grain_size);
}
return
parallel::accumulate_from_subranges<number>
- (std_cxx1x::bind (&internal::SparseMatrix::matrix_norm_sqr_on_subrange
+ (std_cxx11::bind (&internal::SparseMatrix::matrix_norm_sqr_on_subrange
<number,Vector<somenumber> >,
- std_cxx1x::_1, std_cxx1x::_2,
+ std_cxx11::_1, std_cxx11::_2,
val, cols->rowstart, cols->colnums,
- std_cxx1x::cref(v)),
+ std_cxx11::cref(v)),
0, m(),
internal::SparseMatrix::minimum_parallel_grain_size);
}
return
parallel::accumulate_from_subranges<number>
- (std_cxx1x::bind (&internal::SparseMatrix::matrix_scalar_product_on_subrange
+ (std_cxx11::bind (&internal::SparseMatrix::matrix_scalar_product_on_subrange
<number,Vector<somenumber> >,
- std_cxx1x::_1, std_cxx1x::_2,
+ std_cxx11::_1, std_cxx11::_2,
val, cols->rowstart, cols->colnums,
- std_cxx1x::cref(u),
- std_cxx1x::cref(v)),
+ std_cxx11::cref(u),
+ std_cxx11::cref(v)),
0, m(),
internal::SparseMatrix::minimum_parallel_grain_size);
}
return
std::sqrt (parallel::accumulate_from_subranges<number>
- (std_cxx1x::bind (&internal::SparseMatrix::residual_sqr_on_subrange
+ (std_cxx11::bind (&internal::SparseMatrix::residual_sqr_on_subrange
<number,Vector<somenumber>,Vector<somenumber> >,
- std_cxx1x::_1, std_cxx1x::_2,
+ std_cxx11::_1, std_cxx11::_2,
val, cols->rowstart, cols->colnums,
- std_cxx1x::cref(u),
- std_cxx1x::cref(b),
- std_cxx1x::ref(dst)),
+ std_cxx11::cref(u),
+ std_cxx11::cref(b),
+ std_cxx11::ref(dst)),
0, m(),
internal::SparseMatrix::minimum_parallel_grain_size));
}
#ifdef DEAL_II_WITH_TRILINOS
# include <deal.II/base/subscriptor.h>
-# include <deal.II/base/std_cxx1x/shared_ptr.h>
+# include <deal.II/base/std_cxx11/shared_ptr.h>
# include <deal.II/lac/trilinos_vector_base.h>
# include <deal.II/lac/parallel_vector.h>
* This is a pointer to the preconditioner object that is used when
* applying the preconditioner.
*/
- std_cxx1x::shared_ptr<Epetra_Operator> preconditioner;
+ std_cxx11::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_cxx1x::shared_ptr<Epetra_Map> vector_distributor;
+ std_cxx11::shared_ptr<Epetra_Map> vector_distributor;
};
/**
* A copy of the deal.II matrix into Trilinos format.
*/
- std_cxx1x::shared_ptr<SparseMatrix> trilinos_matrix;
+ std_cxx11::shared_ptr<SparseMatrix> trilinos_matrix;
};
#ifdef DEAL_II_WITH_TRILINOS
-# include <deal.II/base/std_cxx1x/shared_ptr.h>
+# 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>
* side vector and the solution vector, which is passed down to the
* Trilinos solver.
*/
- std_cxx1x::shared_ptr<Epetra_LinearProblem> linear_problem;
+ std_cxx11::shared_ptr<Epetra_LinearProblem> linear_problem;
/**
* A structure that contains the Trilinos solver and preconditioner
* side vector and the solution vector, which is passed down to the
* Trilinos solver.
*/
- std_cxx1x::shared_ptr<Epetra_LinearProblem> linear_problem;
+ std_cxx11::shared_ptr<Epetra_LinearProblem> linear_problem;
/**
* A structure that contains the Trilinos solver and preconditioner
* objects.
*/
- std_cxx1
x::shared_ptr<Amesos_BaseSolver> solver;
+ std_cxx1
1::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_cxx1x/shared_ptr.h>
+# 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_cxx1x::shared_ptr<std::vector<size_type> > colnum_cache;
+ std_cxx11::shared_ptr<std::vector<size_type> > colnum_cache;
/**
* Cache for the values of this row.
*/
- std_cxx1x::shared_ptr<std::vector<TrilinosScalar> > value_cache;
+ std_cxx11::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_cxx1x::shared_ptr<Epetra_Map> column_space_map;
+ std_cxx11::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_cxx1x::shared_ptr<Epetra_FECrsMatrix> matrix;
+ std_cxx11::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_cxx1x::shared_ptr<Epetra_CrsMatrix> nonlocal_matrix;
+ std_cxx11::shared_ptr<Epetra_CrsMatrix> nonlocal_matrix;
/**
* An export object used to communicate the nonlocal matrix.
*/
- std_cxx1x::shared_ptr<Epetra_Export> nonlocal_matrix_exporter;
+ std_cxx11::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_cxx1x/shared_ptr.h>
+# include <deal.II/base/std_cxx11/shared_ptr.h>
# include <Epetra_FECrsGraph.h>
# include <Epetra_Map.h>
* performance, we keep a shared pointer to these entries so that more
* than one accessor can access this data if necessary.
*/
- std_cxx1x::shared_ptr<const std::vector<size_type> > colnum_cache;
+ std_cxx11::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_cxx1x::shared_ptr<Epetra_Map> column_space_map;
+ std_cxx11::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_cxx1x::shared_ptr<Epetra_FECrsGraph> graph;
+ std_cxx11::shared_ptr<Epetra_FECrsGraph> graph;
/**
* A sparsity pattern object for the non-local part of the sparsity
* pattern that is going to be sent to the owning processor. Only used when the particular constructor or reinit method with writable_rows argument is set
*/
- std_cxx1x::shared_ptr<Epetra_CrsGraph> nonlocal_graph;
+ std_cxx11::shared_ptr<Epetra_CrsGraph> nonlocal_graph;
friend class SparseMatrix;
friend class SparsityPatternIterators::Accessor;
#ifdef DEAL_II_WITH_TRILINOS
-# include <deal.II/base/std_cxx1x/shared_ptr.h>
+# 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>
#ifdef DEAL_II_WITH_TRILINOS
#include <deal.II/base/utilities.h>
-# include <deal.II/base/std_cxx1x/shared_ptr.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>
* object requires an existing Epetra_Map for
* storing data when setting it up.
*/
- std_cxx1x::shared_ptr<Epetra_FEVector> vector;
+ std_cxx11::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_cxx1x::shared_ptr<Epetra_MultiVector> nonlocal_vector;
+ std_cxx11::shared_ptr<Epetra_MultiVector> nonlocal_vector;
/**
* Make the reference class a friend.
// ---------------------------------------------------------------------
// $Id$
//
-// Copyright (C) 1999 - 2013 by the deal.II authors
+// Copyright (C) 1999 - 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
dst.reinit (vec_size, true);
if (vec_size>internal::Vector::minimum_parallel_grain_size)
parallel::apply_to_subranges (0U, vec_size,
- std_cxx1x::bind(&internal::Vector::template
+ std_cxx11::bind(&internal::Vector::template
copy_subrange <T,U>,
- std_cxx1x::_1,
- std_cxx1x::_2,
- std_cxx1x::cref(src),
- std_cxx1x::ref(dst)),
+ std_cxx11::_1,
+ std_cxx11::_2,
+ std_cxx11::cref(src),
+ std_cxx11::ref(dst)),
internal::Vector::minimum_parallel_grain_size);
else if (vec_size > 0)
copy_subrange (0U, vec_size, src, dst);
Assert (vec_size!=0, ExcEmptyObject());
if (vec_size>internal::Vector::minimum_parallel_grain_size)
parallel::apply_to_subranges (0U, vec_size,
- std_cxx1x::bind(&internal::Vector::template
+ std_cxx11::bind(&internal::Vector::template
set_subrange<Number>,
- s, std_cxx1x::_1, std_cxx1x::_2, std_cxx1x::ref(*this)),
+ s, std_cxx11::_1, std_cxx11::_2, std_cxx11::ref(*this)),
internal::Vector::minimum_parallel_grain_size);
else if (vec_size > 0)
internal::Vector::set_subrange<Number>(s, 0U, vec_size, *this);
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/matrix_free/helper_functions.h>
-#include <deal.II/base/std_cxx1x/array.h>
+#include <deal.II/base/std_cxx11/array.h>
#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_cxx1x::array<unsigned int, 3> > row_starts;
+ std::vector<std_cxx11::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_cxx1x::shared_ptr<const Utilities::MPI::Partitioner> vector_partitioner;
+ std_cxx11::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_cxx1x::array<unsigned int, 3> > new_row_starts;
+ std::vector<std_cxx11::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_cxx1x::array<unsigned int,3>));
+ memory += (row_starts.capacity()*sizeof(std_cxx11::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_cxx1x::array<unsigned int, 3>)));
+ (out, (row_starts.capacity()*sizeof(std_cxx11::array<unsigned int, 3>)));
out << " Memory dof indices: ";
size_info.print_memory_statistics
(out, MemoryConsumption::memory_consumption (dof_indices));
* In case the class is initialized from MappingFEEvaluation instead of
* MatrixFree, this data structure holds the evaluated shape data.
*/
- std_cxx1x::shared_ptr<internal::MatrixFreeFunctions::ShapeInfo<Number> > stored_shape_info;
+ std_cxx11::shared_ptr<internal::MatrixFreeFunctions::ShapeInfo<Number> > stored_shape_info;
/**
* Stores a pointer to the unit cell shape data, i.e., values, gradients and
// 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_cxx1x::shared_ptr<FEValues<dim> > >
+ std::vector<std_cxx11::shared_ptr<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_cxx1x::function<void (const MatrixFree<dim,Number> &,
+ void cell_loop (const std_cxx11::function<void (const MatrixFree<dim,Number> &,
OutVector &,
const InVector &,
const std::pair<unsigned int,
* 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_cxx1x::bind to bind the class into
+ * method obviates the need to call std_cxx11::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_cxx1x::shared_ptr<const Utilities::MPI::Partitioner> &
+ const std_cxx11::shared_ptr<const Utilities::MPI::Partitioner> &
get_vector_partitioner (const unsigned int vector_component=0) const;
/**
template <int dim, typename Number>
inline
-const std_cxx1x::shared_ptr<const Utilities::MPI::Partitioner> &
+const std_cxx11::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_cxx1x::function<void (const MatrixFree<dim,Number> &,
+(const std_cxx11::function<void (const MatrixFree<dim,Number> &,
OutVector &,
const InVector &,
const std::pair<unsigned int,
// to simplify the function calls, bind away all arguments except the
// cell range
typedef
- std_cxx1x::function<void (const std::pair<unsigned int,unsigned int> &range)>
+ std_cxx11::function<void (const std::pair<unsigned int,unsigned int> &range)>
Worker;
- const Worker func = std_cxx1x::bind (std_cxx1x::ref(cell_operation),
- std_cxx1x::cref(*this),
- std_cxx1x::ref(dst),
- std_cxx1x::cref(src),
- std_cxx1x::_1);
+ 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);
if (task_info.use_partition_partition == true)
{
OutVector &dst,
const InVector &src) const
{
- // here, use std_cxx1x::bind to hand a function handler with the appropriate
+ // here, use std_cxx11::bind to hand a function handler with the appropriate
// argument to the other loop function
- std_cxx1x::function<void (const MatrixFree<dim,Number> &,
+ std_cxx11::function<void (const MatrixFree<dim,Number> &,
OutVector &,
const InVector &,
const std::pair<unsigned int,
unsigned int> &)>
- function = std_cxx1x::bind<void>(function_pointer,
- std_cxx1x::cref(*owning_class),
- std_cxx1x::_1,
- std_cxx1x::_2,
- std_cxx1x::_3,
- std_cxx1x::_4);
+ function = std_cxx11::bind<void>(function_pointer,
+ std_cxx11::cref(*owning_class),
+ std_cxx11::_1,
+ std_cxx11::_2,
+ std_cxx11::_3,
+ std_cxx11::_4);
cell_loop (function, dst, src);
}
OutVector &dst,
const InVector &src) const
{
- // here, use std_cxx1x::bind to hand a function handler with the appropriate
+ // here, use std_cxx11::bind to hand a function handler with the appropriate
// argument to the other loop function
- std_cxx1x::function<void (const MatrixFree<dim,Number> &,
+ std_cxx11::function<void (const MatrixFree<dim,Number> &,
OutVector &,
const InVector &,
const std::pair<unsigned int,
unsigned int> &)>
- function = std_cxx1x::bind<void>(function_pointer,
- std_cxx1x::ref(*owning_class),
- std_cxx1x::_1,
- std_cxx1x::_2,
- std_cxx1x::_3,
- std_cxx1x::_4);
+ function = std_cxx11::bind<void>(function_pointer,
+ std_cxx11::ref(*owning_class),
+ std_cxx11::_1,
+ std_cxx11::_2,
+ std_cxx11::_3,
+ std_cxx11::_4);
cell_loop (function, dst, src);
}
#include <deal.II/base/config.h>
#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/std_cxx1x/shared_ptr.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>
// ---------------------------------------------------------------------
// $Id$
//
-// Copyright (C) 2006 - 2013 by the deal.II authors
+// Copyright (C) 2006 - 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/base/config.h>
#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/std_cxx1x/shared_ptr.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>
{
private:
/// vector of FEValues objects
- std::vector<std_cxx1x::shared_ptr<FEValuesBase<dim, spacedim> > > fevalv;
+ std::vector<std_cxx11::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_cxx1x::shared_ptr<VectorDataBase<dim,spacedim> > &data);
+ void initialize_data(const std_cxx11::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_cxx1x::shared_ptr<VectorDataBase<dim, spacedim> > global_data;
+ std_cxx11::shared_ptr<VectorDataBase<dim, spacedim> > global_data;
/**
* The memory used by this object.
*/
MeshWorker::VectorSelector face_selector;
- std_cxx1x::shared_ptr<MeshWorker::VectorDataBase<dim, spacedim> > cell_data;
- std_cxx1x::shared_ptr<MeshWorker::VectorDataBase<dim, spacedim> > boundary_data;
- std_cxx1x::shared_ptr<MeshWorker::VectorDataBase<dim, spacedim> > face_data;
+ 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;
/* @} */
/**
:
fevalv(0),
multigrid(false),
- global_data(std_cxx1x::shared_ptr<VectorDataBase<dim, sdim> >(new VectorDataBase<dim, sdim>))
+ global_data(std_cxx11::shared_ptr<VectorDataBase<dim, sdim> >(new VectorDataBase<dim, sdim>))
{}
const FESubfaceValues<dim,sdim> *ps = dynamic_cast<const FESubfaceValues<dim,sdim>*>(&p);
if (pc != 0)
- fevalv[i] = std_cxx1x::shared_ptr<FEValuesBase<dim,sdim> > (
+ fevalv[i] = std_cxx11::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_cxx1x::shared_ptr<FEValuesBase<dim,sdim> > (
+ fevalv[i] = std_cxx11::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_cxx1x::shared_ptr<FEValuesBase<dim,sdim> > (
+ fevalv[i] = std_cxx11::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_cxx1x::shared_ptr<FEValuesBase<dim,sdim> > (
+ fevalv[0] = std_cxx11::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_cxx1x::shared_ptr<FEValuesBase<dim,sdim> > (
+ fevalv[i] = std_cxx11::shared_ptr<FEValuesBase<dim,sdim> > (
new FEVALUES (mapping, el.base_element(i), quadrature, flags));
}
}
const BlockInfo *block_info)
{
initialize(el, mapping, block_info);
- std_cxx1x::shared_ptr<VectorData<VECTOR, dim, sdim> > p;
+ std_cxx11::shared_ptr<VectorData<VECTOR, dim, sdim> > p;
VectorDataBase<dim,sdim> *pp;
- p = std_cxx1x::shared_ptr<VectorData<VECTOR, dim, sdim> >(new VectorData<VECTOR, dim, sdim> (cell_selector));
+ p = std_cxx11::shared_ptr<VectorData<VECTOR, dim, sdim> >(new VectorData<VECTOR, 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_cxx1x::shared_ptr<VectorData<VECTOR, dim, sdim> >(new VectorData<VECTOR, dim, sdim> (boundary_selector));
+ p = std_cxx11::shared_ptr<VectorData<VECTOR, dim, sdim> >(new VectorData<VECTOR, dim, sdim> (boundary_selector));
pp = &*p;
pp->initialize(data);
boundary_data = p;
boundary.initialize_data(p);
- p = std_cxx1x::shared_ptr<VectorData<VECTOR, dim, sdim> >(new VectorData<VECTOR, dim, sdim> (face_selector));
+ p = std_cxx11::shared_ptr<VectorData<VECTOR, dim, sdim> >(new VectorData<VECTOR, dim, sdim> (face_selector));
pp = &*p;
pp->initialize(data);
face_data = p;
const BlockInfo *block_info)
{
initialize(el, mapping, block_info);
- std_cxx1x::shared_ptr<VectorData<VECTOR, dim, sdim> > p;
+ std_cxx11::shared_ptr<VectorData<VECTOR, dim, sdim> > p;
- p = std_cxx1x::shared_ptr<VectorData<VECTOR, dim, sdim> >(new VectorData<VECTOR, dim, sdim> (cell_selector));
+ p = std_cxx11::shared_ptr<VectorData<VECTOR, dim, sdim> >(new VectorData<VECTOR, dim, sdim> (cell_selector));
p->initialize(data);
cell_data = p;
cell.initialize_data(p);
- p = std_cxx1x::shared_ptr<VectorData<VECTOR, dim, sdim> >(new VectorData<VECTOR, dim, sdim> (boundary_selector));
+ p = std_cxx11::shared_ptr<VectorData<VECTOR, dim, sdim> >(new VectorData<VECTOR, dim, sdim> (boundary_selector));
p->initialize(data);
boundary_data = p;
boundary.initialize_data(p);
- p = std_cxx1x::shared_ptr<VectorData<VECTOR, dim, sdim> >(new VectorData<VECTOR, dim, sdim> (face_selector));
+ p = std_cxx11::shared_ptr<VectorData<VECTOR, dim, sdim> >(new VectorData<VECTOR, dim, sdim> (face_selector));
p->initialize(data);
face_data = p;
face.initialize_data(p);
const BlockInfo *block_info)
{
initialize(el, mapping, block_info);
- std_cxx1x::shared_ptr<MGVectorData<VECTOR, dim, sdim> > p;
+ std_cxx11::shared_ptr<MGVectorData<VECTOR, dim, sdim> > p;
- p = std_cxx1x::shared_ptr<MGVectorData<VECTOR, dim, sdim> >(new MGVectorData<VECTOR, dim, sdim> (cell_selector));
+ p = std_cxx11::shared_ptr<MGVectorData<VECTOR, dim, sdim> >(new MGVectorData<VECTOR, dim, sdim> (cell_selector));
p->initialize(data);
cell_data = p;
cell.initialize_data(p);
- p = std_cxx1x::shared_ptr<MGVectorData<VECTOR, dim, sdim> >(new MGVectorData<VECTOR, dim, sdim> (boundary_selector));
+ p = std_cxx11::shared_ptr<MGVectorData<VECTOR, dim, sdim> >(new MGVectorData<VECTOR, dim, sdim> (boundary_selector));
p->initialize(data);
boundary_data = p;
boundary.initialize_data(p);
- p = std_cxx1x::shared_ptr<MGVectorData<VECTOR, dim, sdim> >(new MGVectorData<VECTOR, dim, sdim> (face_selector));
+ p = std_cxx11::shared_ptr<MGVectorData<VECTOR, dim, sdim> >(new MGVectorData<VECTOR, dim, sdim> (face_selector));
p->initialize(data);
face_data = p;
face.initialize_data(p);
template<int dim, int sdim>
void
IntegrationInfo<dim,sdim>::initialize_data(
- const std_cxx1x::shared_ptr<VectorDataBase<dim,sdim> > &data)
+ const std_cxx11::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_cxx1x/function.h>
+#include <deal.II/base/std_cxx11/function.h>
#include <vector>
#include <string>
#define __deal2__mesh_worker_local_results_h
#include <deal.II/base/config.h>
-#include <deal.II/base/std_cxx1x/function.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>
// ---------------------------------------------------------------------
// $Id$
//
-// Copyright (C) 2006 - 2013 by the deal.II authors
+// Copyright (C) 2006 - 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
#define __deal2__mesh_worker_loop_h
#include <deal.II/base/config.h>
-#include <deal.II/base/std_cxx1x/function.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>
ITERATOR cell,
DoFInfoBox<dim, DOFINFO> &dof_info,
INFOBOX &info,
- const std_cxx1x::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &cell_worker,
- const std_cxx1x::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &boundary_worker,
- const std_cxx1x::function<void (DOFINFO &, DOFINFO &,
+ 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 LoopControl &loop_control)
typename identity<ITERATOR>::type end,
DOFINFO &dinfo,
INFOBOX &info,
- const std_cxx1x::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &cell_worker,
- const std_cxx1x::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &boundary_worker,
- const std_cxx1x::function<void (DOFINFO &, DOFINFO &,
+ 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,
ASSEMBLER &assembler,
// Loop over all cells
#ifdef DEAL_II_MESHWORKER_PARALLEL
WorkStream::run(begin, end,
- std_cxx1x::bind(&cell_action<INFOBOX, DOFINFO, dim, spacedim, ITERATOR>,
- std_cxx1x::_1, std_cxx1x::_3, std_cxx1x::_2,
+ 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_cxx1x::bind(&internal::assemble<dim,DOFINFO,ASSEMBLER>, std_cxx1x::_1, &assembler),
+ std_cxx11::bind(&internal::assemble<dim,DOFINFO,ASSEMBLER>, std_cxx11::_1, &assembler),
info, dof_info);
#else
for (ITERATOR cell = begin; cell != end; ++cell)
typename identity<ITERATOR>::type end,
DOFINFO &dinfo,
INFOBOX &info,
- const std_cxx1x::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &cell_worker,
- const std_cxx1x::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &boundary_worker,
- const std_cxx1x::function<void (DOFINFO &, DOFINFO &,
+ 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,
ASSEMBLER &assembler,
typename identity<ITERATOR>::type end,
DOFINFO &dinfo,
INFOBOX &info,
- const std_cxx1x::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &cell_worker,
- const std_cxx1x::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &boundary_worker,
- const std_cxx1x::function<void (DOFINFO &, DOFINFO &,
+ 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,
ASSEMBLER &assembler,
typename identity<ITERATOR>::type end,
DoFInfo<dim, spacedim> &dof_info,
IntegrationInfoBox<dim, spacedim> &box,
- const std_cxx1x::function<void (DoFInfo<dim>&, IntegrationInfo<dim, spacedim>&)> &cell_worker,
- const std_cxx1x::function<void (DoFInfo<dim>&, IntegrationInfo<dim, spacedim>&)> &boundary_worker,
- const std_cxx1x::function<void (DoFInfo<dim> &, DoFInfo<dim> &,
+ const std_cxx11::function<void (DoFInfo<dim>&, IntegrationInfo<dim, spacedim>&)> &cell_worker,
+ const std_cxx11::function<void (DoFInfo<dim>&, IntegrationInfo<dim, spacedim>&)> &boundary_worker,
+ const std_cxx11::function<void (DoFInfo<dim> &, DoFInfo<dim> &,
IntegrationInfo<dim, spacedim> &,
IntegrationInfo<dim, spacedim> &)> &face_worker,
ASSEMBLER &assembler,
typename identity<ITERATOR>::type end,
DoFInfo<dim, spacedim> &dof_info,
IntegrationInfoBox<dim, spacedim> &box,
- const std_cxx1x::function<void (DoFInfo<dim>&, IntegrationInfo<dim, spacedim>&)> &cell_worker,
- const std_cxx1x::function<void (DoFInfo<dim>&, IntegrationInfo<dim, spacedim>&)> &boundary_worker,
- const std_cxx1x::function<void (DoFInfo<dim> &, DoFInfo<dim> &,
+ const std_cxx11::function<void (DoFInfo<dim>&, IntegrationInfo<dim, spacedim>&)> &cell_worker,
+ const std_cxx11::function<void (DoFInfo<dim>&, IntegrationInfo<dim, spacedim>&)> &boundary_worker,
+ const std_cxx11::function<void (DoFInfo<dim> &, DoFInfo<dim> &,
IntegrationInfo<dim, spacedim> &,
IntegrationInfo<dim, spacedim> &)> &face_worker,
ASSEMBLER &assembler,
ASSEMBLER &assembler,
bool cells_first)
{
- std_cxx1x::function<void (DoFInfo<dim>&, IntegrationInfo<dim, spacedim>&)> cell_worker;
- std_cxx1x::function<void (DoFInfo<dim>&, IntegrationInfo<dim, spacedim>&)> boundary_worker;
- std_cxx1x::function<void (DoFInfo<dim> &, DoFInfo<dim> &,
+ 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;
if (integrator.use_cell)
- cell_worker = std_cxx1x::bind(&LocalIntegrator<dim, spacedim>::cell, &integrator, std_cxx1x::_1, std_cxx1x::_2);
+ cell_worker = std_cxx11::bind(&LocalIntegrator<dim, spacedim>::cell, &integrator, std_cxx11::_1, std_cxx11::_2);
if (integrator.use_boundary)
- boundary_worker = std_cxx1x::bind(&LocalIntegrator<dim, spacedim>::boundary, &integrator, std_cxx1x::_1, std_cxx1x::_2);
+ boundary_worker = std_cxx11::bind(&LocalIntegrator<dim, spacedim>::boundary, &integrator, std_cxx11::_1, std_cxx11::_2);
if (integrator.use_face)
- face_worker = std_cxx1x::bind(&LocalIntegrator<dim, spacedim>::face, &integrator, std_cxx1x::_1, std_cxx1x::_2, std_cxx1x::_3, std_cxx1x::_4);
+ face_worker = std_cxx11::bind(&LocalIntegrator<dim, spacedim>::face, &integrator, std_cxx11::_1, std_cxx11::_2, std_cxx11::_3, std_cxx11::_4);
loop<dim, spacedim>
(begin, end,
ASSEMBLER &assembler,
const LoopControl &lctrl = LoopControl())
{
- std_cxx1x::function<void (DoFInfo<dim>&, IntegrationInfo<dim, spacedim>&)> cell_worker;
- std_cxx1x::function<void (DoFInfo<dim>&, IntegrationInfo<dim, spacedim>&)> boundary_worker;
- std_cxx1x::function<void (DoFInfo<dim> &, DoFInfo<dim> &,
+ 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;
if (integrator.use_cell)
- cell_worker = std_cxx1x::bind(&LocalIntegrator<dim, spacedim>::cell, &integrator, std_cxx1x::_1, std_cxx1x::_2);
+ cell_worker = std_cxx11::bind(&LocalIntegrator<dim, spacedim>::cell, &integrator, std_cxx11::_1, std_cxx11::_2);
if (integrator.use_boundary)
- boundary_worker = std_cxx1x::bind(&LocalIntegrator<dim, spacedim>::boundary, &integrator, std_cxx1x::_1, std_cxx1x::_2);
+ boundary_worker = std_cxx11::bind(&LocalIntegrator<dim, spacedim>::boundary, &integrator, std_cxx11::_1, std_cxx11::_2);
if (integrator.use_face)
- face_worker = std_cxx1x::bind(&LocalIntegrator<dim, spacedim>::face, &integrator, std_cxx1x::_1, std_cxx1x::_2, std_cxx1x::_3, std_cxx1x::_4);
+ face_worker = std_cxx11::bind(&LocalIntegrator<dim, spacedim>::face, &integrator, std_cxx11::_1, std_cxx11::_2, std_cxx11::_3, std_cxx11::_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_cxx1x/shared_ptr.h>
+#include <deal.II/base/std_cxx11/shared_ptr.h>
DEAL_II_NAMESPACE_OPEN
*/
std::size_t memory_consumption () const;
private:
- MGLevelObject<std_cxx1
x::shared_ptr<PointerMatrixBase<VECTOR> > > matrices;
+ MGLevelObject<std_cxx1
1::shared_ptr<PointerMatrixBase<VECTOR> > > matrices;
};
}
{
matrices.resize(p.min_level(), p.max_level());
for (unsigned int level=p.min_level(); level <= p.max_level(); ++level)
- matrices[level] = std_cxx1
x::shared_ptr<PointerMatrixBase<VECTOR> > (new_pointer_matrix_base(p[level], VECTOR()));
+ matrices[level] = std_cxx1
1::shared_ptr<PointerMatrixBase<VECTOR> > (new_pointer_matrix_base(p[level], VECTOR()));
}
#include <deal.II/dofs/dof_handler.h>
-#include <deal.II/base/std_cxx1x/shared_ptr.h>
+#include <deal.II/base/std_cxx11/shared_ptr.h>
DEAL_II_NAMESPACE_OPEN
/**
* Sparsity patterns for transfer matrices.
*/
- std::vector<std_cxx1x::shared_ptr<typename internal::MatrixSelector<VECTOR>::Sparsity> > prolongation_sparsities;
+ std::vector<std_cxx11::shared_ptr<typename internal::MatrixSelector<VECTOR>::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_cxx1x::shared_ptr<typename internal::MatrixSelector<VECTOR>::Matrix> > prolongation_matrices;
+ std::vector<std_cxx11::shared_ptr<typename internal::MatrixSelector<VECTOR>::Matrix> > prolongation_matrices;
/**
* Mapping for the copy_to_mg() and copy_from_mg() functions. Here only
#include <deal.II/dofs/dof_handler.h>
-#include <deal.II/base/std_cxx1x/shared_ptr.h>
+#include <deal.II/base/std_cxx11/shared_ptr.h>
DEAL_II_NAMESPACE_OPEN
DeclException0(ExcMatricesNotBuilt);
private:
- std::vector<std_cxx1x::shared_ptr<BlockSparsityPattern> > prolongation_sparsities;
+ std::vector<std_cxx11::shared_ptr<BlockSparsityPattern> > prolongation_sparsities;
protected:
* while row indices belong to the
* child cell, i.e. the fine level.
*/
- std::vector<std_cxx1x::shared_ptr<BlockSparseMatrix<double> > > prolongation_matrices;
+ std::vector<std_cxx11::shared_ptr<BlockSparseMatrix<double> > > prolongation_matrices;
/**
* Mapping for the
#include <deal.II/base/config.h>
-#include <deal.II/base/std_cxx1x/shared_ptr.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>
DeclException0(ExcMatricesNotBuilt);
private:
- std::vector<std_cxx1x::shared_ptr<BlockSparsityPattern> > prolongation_sparsities;
+ std::vector<std_cxx11::shared_ptr<BlockSparsityPattern> > prolongation_sparsities;
protected:
* while row indices belong to the
* child cell, i.e. the fine level.
*/
- std::vector<std_cxx1x::shared_ptr<BlockSparseMatrix<double> > > prolongation_matrices;
+ std::vector<std_cxx11::shared_ptr<BlockSparseMatrix<double> > > prolongation_matrices;
/**
* Holds the mapping for the
#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_cxx1x/shared_ptr.h>
+#include <deal.II/base/std_cxx11/shared_ptr.h>
DEAL_II_NAMESPACE_OPEN
#include <deal.II/base/config.h>
#include <deal.II/numerics/data_out_dof_data.h>
-#include <deal.II/base/std_cxx1x/shared_ptr.h>
+#include <deal.II/base/std_cxx11/shared_ptr.h>
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_cxx1x::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > &finite_elements,
+ const std::vector<std_cxx11::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_cxx1x/shared_ptr.h>
+#include <deal.II/base/std_cxx11/shared_ptr.h>
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_cxx1x::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > &finite_elements,
+ const std::vector<std_cxx11::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > &finite_elements,
const UpdateFlags update_flags,
const bool use_face_values);
ParallelDataBase (const ParallelDataBase &data);
template <typename DH>
- void reinit_all_fe_values(std::vector<std_cxx1x::shared_ptr<DataEntryBase<DH> > > &dof_data,
+ void reinit_all_fe_values(std::vector<std_cxx11::shared_ptr<DataEntryBase<DH> > > &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_cxx1x::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > finite_elements;
+ const std::vector<std_cxx11::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > finite_elements;
const UpdateFlags update_flags;
- std::vector<std_cxx1x::shared_ptr<dealii::hp::FEValues<dim,spacedim> > > x_fe_values;
- std::vector<std_cxx1x::shared_ptr<dealii::hp::FEFaceValues<dim,spacedim> > > x_fe_face_values;
+ 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;
};
}
}
/**
* List of data elements with vectors of values for each degree of freedom.
*/
- std::vector<std_cxx1x::shared_ptr<internal::DataOut::DataEntryBase<DH> > > dof_data;
+ std::vector<std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DH> > > dof_data;
/**
* List of data elements with vectors of values for each cell.
*/
- std::vector<std_cxx1x::shared_ptr<internal::DataOut::DataEntryBase<DH> > > cell_data;
+ std::vector<std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DH> > > 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_cxx1x::shared_ptr<dealii::hp::FECollection<DH::dimension,DH::space_dimension> > >
+ std::vector<std_cxx11::shared_ptr<dealii::hp::FECollection<DH::dimension,DH::space_dimension> > >
get_finite_elements() const;
/**
* function. See there for a more extensive documentation.
*/
virtual
- std::vector<std_cxx1x::tuple<unsigned int, unsigned int, std::string> >
+ std::vector<std_cxx11::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_cxx1x::get<0>(get_vector_data_ranges()[i]) ==
- std_cxx1x::get<0>(source.get_vector_data_ranges()[i]),
+ Assert (std_cxx11::get<0>(get_vector_data_ranges()[i]) ==
+ std_cxx11::get<0>(source.get_vector_data_ranges()[i]),
ExcMessage ("Both sources need to declare the same components "
"as vectors."));
- Assert (std_cxx1x::get<1>(get_vector_data_ranges()[i]) ==
- std_cxx1x::get<1>(source.get_vector_data_ranges()[i]),
+ Assert (std_cxx11::get<1>(get_vector_data_ranges()[i]) ==
+ std_cxx11::get<1>(source.get_vector_data_ranges()[i]),
ExcMessage ("Both sources need to declare the same components "
"as vectors."));
- Assert (std_cxx1x::get<2>(get_vector_data_ranges()[i]) ==
- std_cxx1x::get<2>(source.get_vector_data_ranges()[i]),
+ Assert (std_cxx11::get<2>(get_vector_data_ranges()[i]) ==
+ std_cxx11::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_cxx1x::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > &finite_elements,
+ const std::vector<std_cxx11::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > &finite_elements,
const UpdateFlags update_flags);
std::vector<Point<dim> > patch_normals;
const unsigned int n_patches_per_circle,
const std::vector<unsigned int> &n_postprocessor_outputs,
const Mapping<dim,spacedim> &mapping,
- const std::vector<std_cxx1x::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > &finite_elements,
+ const std::vector<std_cxx11::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_cxx1x/tuple.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/vector_tools.h>
#include <deal.II/numerics/matrix_tools.h>
-#include <deal.II/base/std_cxx1x/array.h>
+#include <deal.II/base/std_cxx11/array.h>
#include <numeric>
#include <algorithm>
#include <vector>
template <int dim>
struct PointComparator
{
- bool operator ()(const std_cxx1x::array<types::global_dof_index,dim> &p1,
- const std_cxx1x::array<types::global_dof_index,dim> &p2)
+ bool operator ()(const std_cxx11::array<types::global_dof_index,dim> &p1,
+ const std_cxx11::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_cxx1x::array<types::global_dof_index,dim>, PointComparator<dim> > vector_dofs;
+ std::set<std_cxx11::array<types::global_dof_index,dim>, PointComparator<dim> > vector_dofs;
std::vector<types::global_dof_index> face_dofs;
- std::map<std_cxx1x::array<types::global_dof_index,dim>, Vector<double> >
+ std::map<std_cxx11::array<types::global_dof_index,dim>, Vector<double> >
dof_vector_to_b_values;
std::set<types::boundary_id>::iterator b_id;
- std::vector<std_cxx1x::array<types::global_dof_index,dim> > cell_vector_dofs;
+ std::vector<std_cxx11::array<types::global_dof_index,dim> > cell_vector_dofs;
for (typename DH<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_cxx1x::array<types::global_dof_index,dim>,
+ for (typename std::set<std_cxx11::array<types::global_dof_index,dim>,
PointComparator<dim> >::const_iterator it=vector_dofs.begin();
it!=vector_dofs.end(); ++it)
{
#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_cxx1x/shared_ptr.h>
+#include <deal.II/base/std_cxx11/shared_ptr.h>
#include <deal.II/base/mpi.h>
#include <cstring>
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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::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_cxx1x::get<1>(vector_data_ranges[n_th_vector]) >=
- std_cxx1x::get<0>(vector_data_ranges[n_th_vector]),
- ExcLowerRange (std_cxx1x::get<1>(vector_data_ranges[n_th_vector]),
- std_cxx1x::get<0>(vector_data_ranges[n_th_vector])));
- AssertThrow (std_cxx1x::get<1>(vector_data_ranges[n_th_vector]) < n_data_sets,
- ExcIndexRange (std_cxx1x::get<1>(vector_data_ranges[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]),
0, n_data_sets));
- AssertThrow (std_cxx1x::get<1>(vector_data_ranges[n_th_vector]) + 1
- - std_cxx1x::get<0>(vector_data_ranges[n_th_vector]) <= 3,
+ AssertThrow (std_cxx11::get<1>(vector_data_ranges[n_th_vector]) + 1
+ - std_cxx11::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_cxx1x::get<0>(vector_data_ranges[n_th_vector]);
- i<=std_cxx1x::get<1>(vector_data_ranges[n_th_vector]);
+ 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]);
++i)
data_set_written[i] = true;
// name has been specified
out << "VECTORS ";
- if (std_cxx1x::get<2>(vector_data_ranges[n_th_vector]) != "")
- out << std_cxx1x::get<2>(vector_data_ranges[n_th_vector]);
+ if (std_cxx11::get<2>(vector_data_ranges[n_th_vector]) != "")
+ out << std_cxx11::get<2>(vector_data_ranges[n_th_vector]);
else
{
- for (unsigned int i=std_cxx1x::get<0>(vector_data_ranges[n_th_vector]);
- i<std_cxx1x::get<1>(vector_data_ranges[n_th_vector]);
+ 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]);
++i)
out << data_names[i] << "__";
- out << data_names[std_cxx1x::get<1>(vector_data_ranges[n_th_vector])];
+ out << data_names[std_cxx11::get<1>(vector_data_ranges[n_th_vector])];
}
out << " double"
// components
for (unsigned int n=0; n<n_nodes; ++n)
{
- switch (std_cxx1x::get<1>(vector_data_ranges[n_th_vector]) -
- std_cxx1x::get<0>(vector_data_ranges[n_th_vector]))
+ switch (std_cxx11::get<1>(vector_data_ranges[n_th_vector]) -
+ std_cxx11::get<0>(vector_data_ranges[n_th_vector]))
{
case 0:
- out << data_vectors(std_cxx1x::get<0>(vector_data_ranges[n_th_vector]), n) << " 0 0"
+ out << data_vectors(std_cxx11::get<0>(vector_data_ranges[n_th_vector]), n) << " 0 0"
<< '\n';
break;
case 1:
- out << data_vectors(std_cxx1x::get<0>(vector_data_ranges[n_th_vector]), n) << ' '<< data_vectors(std_cxx1x::get<0>(vector_data_ranges[n_th_vector])+1, n) << " 0"
+ 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"
<< '\n';
break;
case 2:
- out << data_vectors(std_cxx1x::get<0>(vector_data_ranges[n_th_vector]), n) << ' '<< data_vectors(std_cxx1x::get<0>(vector_data_ranges[n_th_vector])+1, n) << ' '<< data_vectors(std_cxx1x::get<0>(vector_data_ranges[n_th_vector])+2, n)
+ 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)
<< '\n';
break;
void
write_vtu (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
- const std::vector<std_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::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_cxx1x::get<0>(vector_data_ranges[n_th_vector]);
- i<=std_cxx1x::get<1>(vector_data_ranges[n_th_vector]);
+ 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]);
++i)
data_set_written[i] = true;
// name has been specified
out << " <DataArray type=\"Float64\" Name=\"";
- if (std_cxx1x::get<2>(vector_data_ranges[n_th_vector]) != "")
- out << std_cxx1x::get<2>(vector_data_ranges[n_th_vector]);
+ if (std_cxx11::get<2>(vector_data_ranges[n_th_vector]) != "")
+ out << std_cxx11::get<2>(vector_data_ranges[n_th_vector]);
else
{
- for (unsigned int i=std_cxx1x::get<0>(vector_data_ranges[n_th_vector]);
- i<std_cxx1x::get<1>(vector_data_ranges[n_th_vector]);
+ 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]);
++i)
out << data_names[i] << "__";
- out << data_names[std_cxx1x::get<1>(vector_data_ranges[n_th_vector])];
+ out << data_names[std_cxx11::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_cxx1x::get<1>(vector_data_ranges[n_th_vector]) >=
- std_cxx1x::get<0>(vector_data_ranges[n_th_vector]),
- ExcLowerRange (std_cxx1x::get<1>(vector_data_ranges[n_th_vector]),
- std_cxx1x::get<0>(vector_data_ranges[n_th_vector])));
- AssertThrow (std_cxx1x::get<1>(vector_data_ranges[n_th_vector]) < n_data_sets,
- ExcIndexRange (std_cxx1x::get<1>(vector_data_ranges[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]),
0, n_data_sets));
- AssertThrow (std_cxx1x::get<1>(vector_data_ranges[n_th_vector]) + 1
- - std_cxx1x::get<0>(vector_data_ranges[n_th_vector]) <= 3,
+ AssertThrow (std_cxx11::get<1>(vector_data_ranges[n_th_vector]) + 1
+ - std_cxx11::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_cxx1x::get<0>(vector_data_ranges[n_th_vector]);
- i<=std_cxx1x::get<1>(vector_data_ranges[n_th_vector]);
+ 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]);
++i)
data_set_written[i] = true;
// name has been specified
out << " <DataArray type=\"Float64\" Name=\"";
- if (std_cxx1x::get<2>(vector_data_ranges[n_th_vector]) != "")
- out << std_cxx1x::get<2>(vector_data_ranges[n_th_vector]);
+ if (std_cxx11::get<2>(vector_data_ranges[n_th_vector]) != "")
+ out << std_cxx11::get<2>(vector_data_ranges[n_th_vector]);
else
{
- for (unsigned int i=std_cxx1x::get<0>(vector_data_ranges[n_th_vector]);
- i<std_cxx1x::get<1>(vector_data_ranges[n_th_vector]);
+ 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]);
++i)
out << data_names[i] << "__";
- out << data_names[std_cxx1x::get<1>(vector_data_ranges[n_th_vector])];
+ out << data_names[std_cxx11::get<1>(vector_data_ranges[n_th_vector])];
}
out << "\" NumberOfComponents=\"3\" format=\""
for (unsigned int n=0; n<n_nodes; ++n)
{
- switch (std_cxx1x::get<1>(vector_data_ranges[n_th_vector]) -
- std_cxx1x::get<0>(vector_data_ranges[n_th_vector]))
+ switch (std_cxx11::get<1>(vector_data_ranges[n_th_vector]) -
+ std_cxx11::get<0>(vector_data_ranges[n_th_vector]))
{
case 0:
- data.push_back (data_vectors(std_cxx1x::get<0>(vector_data_ranges[n_th_vector]), n));
+ data.push_back (data_vectors(std_cxx11::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_cxx1x::get<0>(vector_data_ranges[n_th_vector]), n));
- data.push_back (data_vectors(std_cxx1x::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]), n));
+ data.push_back (data_vectors(std_cxx11::get<0>(vector_data_ranges[n_th_vector])+1, n));
data.push_back (0);
break;
case 2:
- data.push_back (data_vectors(std_cxx1x::get<0>(vector_data_ranges[n_th_vector]), n));
- data.push_back (data_vectors(std_cxx1x::get<0>(vector_data_ranges[n_th_vector])+1, n));
- data.push_back (data_vectors(std_cxx1x::get<0>(vector_data_ranges[n_th_vector])+2, n));
+ 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));
break;
default:
template <int dim, int spacedim>
void write_svg (const std::vector<Patch<dim,spacedim> > &,
const std::vector<std::string> &,
- const std::vector<std_cxx1x::tuple<unsigned int, unsigned int, std::string> > &,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::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_cxx1x::get<0>(vector_data_ranges[i]) << ' '
- << std_cxx1x::get<1>(vector_data_ranges[i]) << '\n'
- << std_cxx1x::get<2>(vector_data_ranges[i]) << '\n';
+ 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 << '\n';
// make sure everything now gets to
AssertThrow (out, ExcIO());
const std::vector<std::string> data_names = get_dataset_names();
- const std::vector<std_cxx1x::tuple<unsigned int, unsigned int, std::string> > vector_data_ranges
+ const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > vector_data_ranges
= get_vector_data_ranges();
const unsigned int n_data_sets = data_names.size();
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_cxx1x::get<1>(vector_data_ranges[n_th_vector]) >=
- std_cxx1x::get<0>(vector_data_ranges[n_th_vector]),
- ExcLowerRange (std_cxx1x::get<1>(vector_data_ranges[n_th_vector]),
- std_cxx1x::get<0>(vector_data_ranges[n_th_vector])));
- AssertThrow (std_cxx1x::get<1>(vector_data_ranges[n_th_vector]) < n_data_sets,
- ExcIndexRange (std_cxx1x::get<1>(vector_data_ranges[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]),
0, n_data_sets));
- AssertThrow (std_cxx1x::get<1>(vector_data_ranges[n_th_vector]) + 1
- - std_cxx1x::get<0>(vector_data_ranges[n_th_vector]) <= 3,
+ AssertThrow (std_cxx11::get<1>(vector_data_ranges[n_th_vector]) + 1
+ - std_cxx11::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_cxx1x::get<0>(vector_data_ranges[n_th_vector]);
- i<=std_cxx1x::get<1>(vector_data_ranges[n_th_vector]);
+ 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]);
++i)
data_set_written[i] = true;
// name has been specified
out << " <PDataArray type=\"Float64\" Name=\"";
- if (std_cxx1x::get<2>(vector_data_ranges[n_th_vector]) != "")
- out << std_cxx1x::get<2>(vector_data_ranges[n_th_vector]);
+ if (std_cxx11::get<2>(vector_data_ranges[n_th_vector]) != "")
+ out << std_cxx11::get<2>(vector_data_ranges[n_th_vector]);
else
{
- for (unsigned int i=std_cxx1x::get<0>(vector_data_ranges[n_th_vector]);
- i<std_cxx1x::get<1>(vector_data_ranges[n_th_vector]);
+ 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]);
++i)
out << data_names[i] << "__";
- out << data_names[std_cxx1x::get<1>(vector_data_ranges[n_th_vector])];
+ out << data_names[std_cxx11::get<1>(vector_data_ranges[n_th_vector])];
}
out << "\" NumberOfComponents=\"3\" format=\"ascii\"/>\n";
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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::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_cxx1x::get<0>(vector_data_ranges[n_th_vector]) < data_set) n_th_vector++;
+ while (n_th_vector < vector_data_ranges.size() && std_cxx11::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_cxx1x::get<0>(vector_data_ranges[n_th_vector]) == data_set)
+ if (n_th_vector < vector_data_ranges.size() && std_cxx11::get<0>(vector_data_ranges[n_th_vector]) == data_set)
{
// Multiple dimensions
- pt_data_vector_dim = std_cxx1x::get<1>(vector_data_ranges[n_th_vector]) - std_cxx1x::get<0>(vector_data_ranges[n_th_vector])+1;
+ 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;
// Ensure the dimensionality of the data is correct
- AssertThrow (std_cxx1x::get<1>(vector_data_ranges[n_th_vector]) >= std_cxx1x::get<0>(vector_data_ranges[n_th_vector]),
- ExcLowerRange (std_cxx1x::get<1>(vector_data_ranges[n_th_vector]), std_cxx1x::get<0>(vector_data_ranges[n_th_vector])));
- AssertThrow (std_cxx1x::get<1>(vector_data_ranges[n_th_vector]) < n_data_sets,
- ExcIndexRange (std_cxx1x::get<1>(vector_data_ranges[n_th_vector]), 0, n_data_sets));
+ 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));
// Determine the vector name
// Concatenate all the
// component names with double
// underscores unless a vector
// name has been specified
- if (std_cxx1x::get<2>(vector_data_ranges[n_th_vector]) != "")
+ if (std_cxx11::get<2>(vector_data_ranges[n_th_vector]) != "")
{
- vector_name = std_cxx1x::get<2>(vector_data_ranges[n_th_vector]);
+ vector_name = std_cxx11::get<2>(vector_data_ranges[n_th_vector]);
}
else
{
vector_name = "";
- for (i=std_cxx1x::get<0>(vector_data_ranges[n_th_vector]); i<std_cxx1x::get<1>(vector_data_ranges[n_th_vector]); ++i)
+ for (i=std_cxx11::get<0>(vector_data_ranges[n_th_vector]); i<std_cxx11::get<1>(vector_data_ranges[n_th_vector]); ++i)
vector_name += data_names[i] + "__";
- vector_name += data_names[std_cxx1x::get<1>(vector_data_ranges[n_th_vector])];
+ vector_name += data_names[std_cxx11::get<1>(vector_data_ranges[n_th_vector])];
}
}
else
template <int dim, int spacedim>
-std::vector<std_cxx1x::tuple<unsigned int, unsigned int, std::string> >
+std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> >
DataOutInterface<dim,spacedim>::get_vector_data_ranges () const
{
- return std::vector<std_cxx1x::tuple<unsigned int, unsigned int, std::string> >();
+ return std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> >();
}
tmp.swap (dataset_names);
}
{
- std::vector<std_cxx1x::tuple<unsigned int, unsigned int, std::string> > tmp;
+ std::vector<std_cxx11::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_cxx1x::get<0>(vector_data_ranges[i])
- >> std_cxx1x::get<1>(vector_data_ranges[i]);
+ in >> std_cxx11::get<0>(vector_data_ranges[i])
+ >> std_cxx11::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_cxx1x::get<2>(vector_data_ranges[i]) = name;
+ std_cxx11::get<2>(vector_data_ranges[i]) = name;
}
Assert (in, ExcIO());
"as vectors."));
for (unsigned int i=0; i<get_vector_data_ranges().size(); ++i)
{
- Assert (std_cxx1x::get<0>(get_vector_data_ranges()[i]) ==
- std_cxx1x::get<0>(source.get_vector_data_ranges()[i]),
+ Assert (std_cxx11::get<0>(get_vector_data_ranges()[i]) ==
+ std_cxx11::get<0>(source.get_vector_data_ranges()[i]),
ExcMessage ("Both sources need to declare the same components "
"as vectors."));
- Assert (std_cxx1x::get<1>(get_vector_data_ranges()[i]) ==
- std_cxx1x::get<1>(source.get_vector_data_ranges()[i]),
+ Assert (std_cxx11::get<1>(get_vector_data_ranges()[i]) ==
+ std_cxx11::get<1>(source.get_vector_data_ranges()[i]),
ExcMessage ("Both sources need to declare the same components "
"as vectors."));
- Assert (std_cxx1x::get<2>(get_vector_data_ranges()[i]) ==
- std_cxx1x::get<2>(source.get_vector_data_ranges()[i]),
+ Assert (std_cxx11::get<2>(get_vector_data_ranges()[i]) ==
+ std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> >
+std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::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_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
const Deal_II_IntermediateFlags &flags,
std::ostream &out);
\}
template <int dim, typename Number>
ScalarFunctionFromFunctionObject<dim, Number>::
-ScalarFunctionFromFunctionObject (const std_cxx1x::function<Number (const Point<dim, Number> &)> &function_object)
+ScalarFunctionFromFunctionObject (const std_cxx11::function<Number (const Point<dim, Number> &)> &function_object)
:
Function<dim, Number>(1),
function_object (function_object)
template <int dim, typename Number>
VectorFunctionFromScalarFunctionObject<dim, Number>::
-VectorFunctionFromScalarFunctionObject (const std_cxx1x::function<Number (const Point<dim, Number> &)> &function_object,
+VectorFunctionFromScalarFunctionObject (const std_cxx11::function<Number (const Point<dim, Number> &)> &function_object,
const unsigned int selected_component,
const unsigned int n_components)
:
template <int dim>
InterpolatedTensorProductGridData<dim>::
- InterpolatedTensorProductGridData(const std_cxx1x::array<std::vector<double>,dim> &coordinate_values,
+ InterpolatedTensorProductGridData(const std_cxx11::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_cxx1x::array<std::pair<double,double>,dim> &interval_endpoints,
- const std_cxx1x::array<unsigned int,dim> &n_subintervals,
+ InterpolatedUniformGridData(const std_cxx11::array<std::pair<double,double>,dim> &interval_endpoints,
+ const std_cxx11::array<unsigned int,dim> &n_subintervals,
const Table<dim,double> &data_values)
:
interval_endpoints (interval_endpoints),
std::string str;
std::getline(is, str, '>');
- std_cxx1
x::shared_ptr<PatternBase> base_pattern (pattern_factory(str));
+ std_cxx1
1::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_cxx1
x::shared_ptr<PatternBase> key_pattern (pattern_factory(key));
- std_cxx1
x::shared_ptr<PatternBase> value_pattern (pattern_factory(value));
+ std_cxx1
1::shared_ptr<PatternBase> key_pattern (pattern_factory(key));
+ std_cxx1
1::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_cxx1x::shared_ptr<const Patterns::PatternBase> > &
+ const std::vector<std_cxx11::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_cxx1x::shared_ptr<const Patterns::PatternBase>
+ patterns.push_back (std_cxx11::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_cxx1
x::shared_ptr<Polynomial<number> > q_data;
+ std_cxx1
1::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_cxx1
x::shared_ptr<Polynomial<number> > q_data;
+ std_cxx1
1::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_cxx1
x::shared_ptr<Polynomial<number> > q_data;
+ std_cxx1
1::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_cxx1
x::shared_ptr<Polynomial<number> > q_data;
+ std_cxx1
1::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_cxx1
x::shared_ptr<Polynomial<number> > q_data;
+ std_cxx1
1::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_cxx1x::shared_ptr<const std::vector<double> > >
+ std::vector<std_cxx11::shared_ptr<const std::vector<double> > >
Legendre::recursive_coefficients(20);
- std::vector<std_cxx1x::shared_ptr<const std::vector<double> > >
+ std::vector<std_cxx11::shared_ptr<const std::vector<double> > >
Legendre::shifted_coefficients(20);
if ((recursive_coefficients.size() < k+1) ||
((recursive_coefficients.size() >= k+1) &&
(recursive_coefficients[k] ==
- std_cxx1x::shared_ptr<const std::vector<double> >())))
+ std_cxx11::shared_ptr<const std::vector<double> >())))
// no, then generate the
// respective coefficients
{
// would appear if we used plain
// pointers.
recursive_coefficients[0] =
- std_cxx1x::shared_ptr<const std::vector<double> >(c0);
+ std_cxx11::shared_ptr<const std::vector<double> >(c0);
recursive_coefficients[1] =
- std_cxx1x::shared_ptr<const std::vector<double> >(c1);
+ std_cxx11::shared_ptr<const std::vector<double> >(c1);
// Compute polynomials
// orthogonal on [0,1]
Polynomial<double>::shift<SHIFT_TYPE> (*c1, -1.);
Polynomial<double>::scale(*c1, 2.);
Polynomial<double>::multiply(*c1, std::sqrt(3.));
- shifted_coefficients[0]=std_cxx1x::shared_ptr<const std::vector<double> >(c0);
- shifted_coefficients[1]=std_cxx1x::shared_ptr<const std::vector<double> >(c1);
+ shifted_coefficients[0]=std_cxx11::shared_ptr<const std::vector<double> >(c0);
+ shifted_coefficients[1]=std_cxx11::shared_ptr<const std::vector<double> >(c1);
}
else
{
// const pointer in the
// coefficients array
recursive_coefficients[k] =
- std_cxx1x::shared_ptr<const std::vector<double> >(ck);
+ std_cxx11::shared_ptr<const std::vector<double> >(ck);
// and compute the
// coefficients for [0,1]
ck = new std::vector<double>(*ck);
Polynomial<double>::scale(*ck, 2.);
Polynomial<double>::multiply(*ck, std::sqrt(2.*k+1.));
shifted_coefficients[k] =
- std_cxx1x::shared_ptr<const std::vector<double> >(ck);
+ std_cxx11::shared_ptr<const std::vector<double> >(ck);
};
};
}
// Reserve space for polynomials up to degree 19. Should be sufficient
// for the start.
- std::vector<std_cxx1x::shared_ptr<const std::vector<double> > >
+ std::vector<std_cxx11::shared_ptr<const std::vector<double> > >
Hierarchical::recursive_coefficients(20);
// now make these arrays
// const
recursive_coefficients[0] =
- std_cxx1x::shared_ptr<const std::vector<double> >(c0);
+ std_cxx11::shared_ptr<const std::vector<double> >(c0);
recursive_coefficients[1] =
- std_cxx1x::shared_ptr<const std::vector<double> >(c1);
+ std_cxx11::shared_ptr<const std::vector<double> >(c1);
}
else if (k==2)
{
(*c2)[2] = 4.*a;
recursive_coefficients[2] =
- std_cxx1x::shared_ptr<const std::vector<double> >(c2);
+ std_cxx11::shared_ptr<const std::vector<double> >(c2);
}
else
{
// const pointer in the
// coefficients array
recursive_coefficients[k] =
- std_cxx1x::shared_ptr<const std::vector<double> >(ck);
+ std_cxx11::shared_ptr<const std::vector<double> >(ck);
};
};
}
#include <deal.II/grid/tria_accessor.h>
#include <deal.II/grid/tria_iterator.h>
-#include <deal.II/base/std_cxx1x/bind.h>
+#include <deal.II/base/std_cxx11/bind.h>
DEAL_II_NAMESPACE_OPEN
offset
= tria->register_data_attach(size,
- std_cxx1x::bind(&SolutionTransfer<dim, VECTOR, DH>::pack_callback,
+ std_cxx11::bind(&SolutionTransfer<dim, VECTOR, DH>::pack_callback,
this,
- std_cxx1x::_1,
- std_cxx1x::_2,
- std_cxx1x::_3));
+ std_cxx11::_1,
+ std_cxx11::_2,
+ std_cxx11::_3));
}
Assert (tria != 0, ExcInternalError());
tria->notify_ready_to_unpack(offset,
- std_cxx1x::bind(&SolutionTransfer<dim, VECTOR, DH>::unpack_callback,
+ std_cxx11::bind(&SolutionTransfer<dim, VECTOR, DH>::unpack_callback,
this,
- std_cxx1x::_1,
- std_cxx1x::_2,
- std_cxx1x::_3,
- std_cxx1x::ref(all_out)));
+ std_cxx11::_1,
+ std_cxx11::_2,
+ std_cxx11::_3,
+ std_cxx11::ref(all_out)));
for (typename std::vector<VECTOR *>::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_cxx1x::function<
+ const typename std::list<std::pair<unsigned int, typename std_cxx11::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_cxx1x::function<
+ typedef std::list<std::pair<unsigned int, typename std_cxx11::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_cxx1x::function<
+ const typename std_cxx11::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_cxx1x::function<void(const cell_iterator &,
+ const std_cxx11::function<void(const cell_iterator &,
const CellStatus,
void *)> &pack_callback)
{
void
Triangulation<dim,spacedim>::
notify_ready_to_unpack (const unsigned int offset,
- const std_cxx1x::function<void (const cell_iterator &,
+ const std_cxx11::function<void (const cell_iterator &,
const CellStatus,
const void *)> &unpack_callback)
{
ensure_existence_of_master_dof_mask (const FiniteElement<dim,spacedim> &fe1,
const FiniteElement<dim,spacedim> &fe2,
const FullMatrix<double> &face_interpolation_matrix,
- std_cxx1x::shared_ptr<std::vector<bool> > &master_dof_mask)
+ std_cxx11::shared_ptr<std::vector<bool> > &master_dof_mask)
{
- if (master_dof_mask == std_cxx1x::shared_ptr<std::vector<bool> >())
+ if (master_dof_mask == std_cxx11::shared_ptr<std::vector<bool> >())
{
- master_dof_mask = std_cxx1x::shared_ptr<std::vector<bool> >
+ master_dof_mask = std_cxx11::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_cxx1x::shared_ptr<FullMatrix<double> > &matrix)
+ std_cxx11::shared_ptr<FullMatrix<double> > &matrix)
{
- if (matrix == std_cxx1x::shared_ptr<FullMatrix<double> >())
+ if (matrix == std_cxx11::shared_ptr<FullMatrix<double> >())
{
- matrix = std_cxx1x::shared_ptr<FullMatrix<double> >
+ matrix = std_cxx11::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_cxx1x::shared_ptr<FullMatrix<double> > &matrix)
+ std_cxx11::shared_ptr<FullMatrix<double> > &matrix)
{
- if (matrix == std_cxx1x::shared_ptr<FullMatrix<double> >())
+ if (matrix == std_cxx11::shared_ptr<FullMatrix<double> >())
{
- matrix = std_cxx1x::shared_ptr<FullMatrix<double> >
+ matrix = std_cxx11::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_cxx1x::shared_ptr<std::pair<FullMatrix<double>,FullMatrix<double> > > &split_matrix)
+ std_cxx11::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_cxx1x::shared_ptr<std::pair<FullMatrix<double>,FullMatrix<double> > >())
+ std_cxx11::shared_ptr<std::pair<FullMatrix<double>,FullMatrix<double> > >())
{
split_matrix
- = std_cxx1x::shared_ptr<std::pair<FullMatrix<double>,FullMatrix<double> > >
+ = std_cxx11::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_cxx1x::shared_ptr<FullMatrix<double> > >
+ Table<2,std_cxx11::shared_ptr<FullMatrix<double> > >
face_interpolation_matrices (n_finite_elements (dof_handler),
n_finite_elements (dof_handler));
- Table<3,std_cxx1x::shared_ptr<FullMatrix<double> > >
+ Table<3,std_cxx11::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_cxx1x::shared_ptr<std::pair<FullMatrix<double>,FullMatrix<double> > > >
+ Table<2,std_cxx11::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_cxx1x::shared_ptr<std::vector<bool> > >
+ Table<2,std_cxx11::shared_ptr<std::vector<bool> > >
master_dof_masks (n_finite_elements (dof_handler),
n_finite_elements (dof_handler));
WorkStream::run(coarse_grid.begin_active(),
coarse_grid.end(),
- std_cxx1x::bind(&compute_intergrid_weights_3<dim,spacedim>,
- std_cxx1x::_1,
- std_cxx1x::_2,
- std_cxx1x::_3,
+ std_cxx11::bind(&compute_intergrid_weights_3<dim,spacedim>,
+ std_cxx11::_1,
+ std_cxx11::_2,
+ std_cxx11::_3,
coarse_component,
- std_cxx1x::cref(coarse_grid.get_fe()),
- std_cxx1x::cref(coarse_to_fine_grid_map),
- std_cxx1x::cref(parameter_dofs),
- std_cxx1x::cref(weight_mapping)),
- std_cxx1x::bind(©_intergrid_weights_3<dim,spacedim>,
- std_cxx1x::_1,
+ std_cxx11::cref(coarse_grid.get_fe()),
+ std_cxx11::cref(coarse_to_fine_grid_map),
+ std_cxx11::cref(parameter_dofs),
+ std_cxx11::cref(weight_mapping)),
+ std_cxx11::bind(©_intergrid_weights_3<dim,spacedim>,
+ std_cxx11::_1,
coarse_component,
- std_cxx1x::cref(coarse_grid.get_fe()),
- std_cxx1x::cref(weight_mapping),
- std_cxx1x::ref(weights)),
+ std_cxx11::cref(coarse_grid.get_fe()),
+ std_cxx11::cref(weight_mapping),
+ std_cxx11::ref(weights)),
scratch,
copy_data);
}
if (multiplicities[i]>0)
{
base_elements[ind] =
- std::make_pair (std_cxx1x::shared_ptr<const FiniteElement<dim,spacedim> >
+ std::make_pair (std_cxx11::shared_ptr<const FiniteElement<dim,spacedim> >
(fes[i]->clone()),
multiplicities[i]);
++ind;
// ---------------------------------------------------------------------
// $Id$
//
-// Copyright (C) 2000 - 2013 by the deal.II authors
+// Copyright (C) 2000 - 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
#include <deal.II/dofs/dof_tools.h>
#include <deal.II/hp/dof_handler.h>
-#include <deal.II/base/std_cxx1x/shared_ptr.h>
+#include <deal.II/base/std_cxx11/shared_ptr.h>
#include <deal.II/base/index_set.h>
template <int dim>
void
- fill_no_codim_fe_names (std::map<std::string,std_cxx1x::shared_ptr<const Subscriptor> > &result)
+ fill_no_codim_fe_names (std::map<std::string,std_cxx11::shared_ptr<const Subscriptor> > &result)
{
- typedef std_cxx1x::shared_ptr<const Subscriptor> FEFactoryPointer;
+ typedef std_cxx11::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_cxx1x::shared_ptr<const Subscriptor> > &result)
+ fill_codim_fe_names (std::map<std::string,std_cxx11::shared_ptr<const Subscriptor> > &result)
{
- typedef std_cxx1x::shared_ptr<const Subscriptor> FEFactoryPointer;
+ typedef std_cxx11::shared_ptr<const Subscriptor> FEFactoryPointer;
result["FE_DGP"]
= FEFactoryPointer(new FETools::FEFactory<FE_DGP<dim,spacedim> >);
// by the functions above.
std::vector<std::vector<
std::map<std::string,
- std_cxx1x::shared_ptr<const Subscriptor> > > >
+ std_cxx11::shared_ptr<const Subscriptor> > > >
fill_default_map()
{
std::vector<std::vector<
std::map<std::string,
- std_cxx1x::shared_ptr<const Subscriptor> > > >
+ std_cxx11::shared_ptr<const Subscriptor> > > >
result(4);
for (unsigned int d=0; d<4; ++d)
static
std::vector<std::vector<
std::map<std::string,
- std_cxx1x::shared_ptr<const Subscriptor> > > >
+ std_cxx11::shared_ptr<const Subscriptor> > > >
fe_name_map = fill_default_map();
}
// Insert the normalized name into
// the map
fe_name_map[dim][spacedim][name] =
- std_cxx1x::shared_ptr<const Subscriptor> (factory);
+ std_cxx11::shared_ptr<const Subscriptor> (factory);
}
FiniteElement<dim,spacedim> *
get_fe_from_name_ext (std::string &name,
const std::map<std::string,
- std_cxx1x::shared_ptr<const Subscriptor> >
+ std_cxx11::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_cxx1x/shared_ptr.h>
+#include <deal.II/base/std_cxx11/shared_ptr.h>
#include <deal.II/base/index_set.h>
// that memory is released again
std::map<const FiniteElement<dim,spacedim> *,
std::map<const FiniteElement<dim,spacedim> *,
- std_cxx1x::shared_ptr<FullMatrix<double> > > >
+ std_cxx11::shared_ptr<FullMatrix<double> > > >
interpolation_matrices;
typename DH1<dim,spacedim>::active_cell_iterator cell1 = dof1.begin_active(),
// there
if (interpolation_matrices[&cell1->get_fe()][&cell2->get_fe()].get() == 0)
{
- std_cxx1x::shared_ptr<FullMatrix<double> >
+ std_cxx11::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_cxx1x::shared_ptr<FullMatrix<double> > > interpolation_matrices;
+ std_cxx11::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_cxx1x::shared_ptr<FullMatrix<double> >
+ std_cxx11::shared_ptr<FullMatrix<double> >
(new FullMatrix<double>(dofs_per_cell1, dofs_per_cell1));
get_back_interpolation_matrix(dof1.get_fe(), fe2,
*interpolation_matrices[&cell->get_fe()]);
invalidate_present_cell();
tria_listener =
cell->get_triangulation().signals.any_change.connect
- (std_cxx1x::bind (&FEValuesBase<dim,spacedim>::invalidate_present_cell,
- std_cxx1x::ref(static_cast<FEValuesBase<dim,spacedim>&>(*this))));
+ (std_cxx11::bind (&FEValuesBase<dim,spacedim>::invalidate_present_cell,
+ std_cxx11::ref(static_cast<FEValuesBase<dim,spacedim>&>(*this))));
}
}
else
// changes
tria_listener =
cell->get_triangulation().signals.post_refinement.connect
- (std_cxx1x::bind (&FEValuesBase<dim,spacedim>::invalidate_present_cell,
- std_cxx1x::ref(static_cast<FEValuesBase<dim,spacedim>&>(*this))));
+ (std_cxx11::bind (&FEValuesBase<dim,spacedim>::invalidate_present_cell,
+ std_cxx11::ref(static_cast<FEValuesBase<dim,spacedim>&>(*this))));
}
}
// information, etc.
DataOutBase::write_vtk (triangulation_to_patches(tria),
std::vector<std::string>(),
- std::vector<std_cxx1x::tuple<unsigned int, unsigned int, std::string> >(),
+ std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> >(),
vtk_flags,
out);
// information, etc.
DataOutBase::write_vtu (triangulation_to_patches(tria),
std::vector<std::string>(),
- std::vector<std_cxx1x::tuple<unsigned int, unsigned int, std::string> >(),
+ std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> >(),
vtu_flags,
out);
#include <deal.II/grid/grid_reordering_internal.h>
#include <deal.II/grid/grid_tools.h>
#include <deal.II/base/utilities.h>
-#include <deal.II/base/std_cxx1x/bind.h>
+#include <deal.II/base/std_cxx11/bind.h>
#include <algorithm>
#include <set>
std::transform(inquads.begin(),
inquads.end(),
std::back_inserter(mquads),
- std_cxx1x::bind(build_quad_from_vertices,
- std_cxx1x::_1,
- std_cxx1x::cref(sides)) );
+ std_cxx11::bind(build_quad_from_vertices,
+ std_cxx11::_1,
+ std_cxx11::cref(sides)) );
// Assign the quads to their sides also.
int qctr = 0;
//
// ---------------------------------------------------------------------
-#include <deal.II/base/std_cxx1x/array.h>
+#include <deal.II/base/std_cxx11/array.h>
#include <deal.II/base/quadrature_lib.h>
#include <deal.II/grid/tria.h>
#include <deal.II/distributed/tria.h>
template<> struct OrientationLookupTable<1>
{
- typedef std_cxx1x::array<unsigned int, GeometryInfo<1>::vertices_per_face> MATCH_T;
+ typedef std_cxx11::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_cxx1x::array<unsigned int, GeometryInfo<2>::vertices_per_face> MATCH_T;
+ typedef std_cxx11::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_cxx1x::array<unsigned int, GeometryInfo<3>::vertices_per_face> MATCH_T;
+ typedef std_cxx11::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_cxx1x::
+ std_cxx11::
array<unsigned int, GeometryInfo<dim>::vertices_per_face> matching;
std::set<unsigned int> face2_vertices;
#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_cxx1x/bind.h>
+#include <deal.II/base/std_cxx11/bind.h>
#include <deal.II/grid/tria.h>
#include <deal.II/grid/tria_levels.h>
#include <cmath>
#include <functional>
-#include <deal.II/base/std_cxx1x/array.h>
+#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_cxx1x::array<bool,GeometryInfo<dim>::lines_per_face> >,
+ std_cxx11::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_cxx1x::array<bool,GeometryInfo<dim>::lines_per_face> orientation;
+ std_cxx11::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_cxx1x::array<bool,GeometryInfo<dim>::lines_per_face> >,
+ std_cxx11::array<bool,GeometryInfo<dim>::lines_per_face> >,
QuadComparator>
::iterator q;
for (q = needed_quads.begin(); quad!=triangulation.end_quad(); ++quad, ++q)
std::vector<boost::signals2::connection> connections;
connections.push_back
- (signals.create.connect (std_cxx1x::bind (&RefinementListener::create_notification,
- std_cxx1x::ref(listener),
- std_cxx1x::cref(*this))));
+ (signals.create.connect (std_cxx11::bind (&RefinementListener::create_notification,
+ std_cxx11::ref(listener),
+ std_cxx11::cref(*this))));
connections.push_back
- (signals.copy.connect (std_cxx1x::bind (&RefinementListener::copy_notification,
- std_cxx1x::ref(listener),
- std_cxx1x::cref(*this),
- std_cxx1x::_1)));
+ (signals.copy.connect (std_cxx11::bind (&RefinementListener::copy_notification,
+ std_cxx11::ref(listener),
+ std_cxx11::cref(*this),
+ std_cxx11::_1)));
connections.push_back
- (signals.pre_refinement.connect (std_cxx1x::bind (&RefinementListener::pre_refinement_notification,
- std_cxx1x::ref(listener),
- std_cxx1x::cref(*this))));
+ (signals.pre_refinement.connect (std_cxx11::bind (&RefinementListener::pre_refinement_notification,
+ std_cxx11::ref(listener),
+ std_cxx11::cref(*this))));
connections.push_back
- (signals.post_refinement.connect (std_cxx1x::bind (&RefinementListener::post_refinement_notification,
- std_cxx1x::ref(listener),
- std_cxx1x::cref(*this))));
+ (signals.post_refinement.connect (std_cxx11::bind (&RefinementListener::post_refinement_notification,
+ std_cxx11::ref(listener),
+ std_cxx11::cref(*this))));
// now push the set of connections into the map
refinement_listener_map.insert (std::make_pair(&listener, connections));
// another thread might have created points in the meantime
if (points[n_intermediate_points].get() == 0)
{
- std_cxx1x::shared_ptr<QGaussLobatto<1> >
+ std_cxx11::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/geometry_info.h>
#include <deal.II/base/thread_management.h>
-#include <deal.II/base/std_cxx1x/bind.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_cxx1x::shared_ptr<DoFIdentities> &identities)
+ std_cxx11::shared_ptr<DoFIdentities> &identities)
{
// see if we need to fill this
// entry, or whether it already
case 0:
{
identities =
- std_cxx1x::shared_ptr<DoFIdentities>
+ std_cxx11::shared_ptr<DoFIdentities>
(new DoFIdentities(fe1.hp_vertex_dof_identities(fe2)));
break;
}
case 1:
{
identities =
- std_cxx1x::shared_ptr<DoFIdentities>
+ std_cxx11::shared_ptr<DoFIdentities>
(new DoFIdentities(fe1.hp_line_dof_identities(fe2)));
break;
}
case 2:
{
identities =
- std_cxx1x::shared_ptr<DoFIdentities>
+ std_cxx11::shared_ptr<DoFIdentities>
(new DoFIdentities(fe1.hp_quad_dof_identities(fe2)));
break;
}
tria_listeners.push_back
(tria.signals.pre_refinement
- .connect (std_cxx1x::bind (&DoFHandler<dim,spacedim>::pre_refinement_action,
- std_cxx1x::ref(*this))));
+ .connect (std_cxx11::bind (&DoFHandler<dim,spacedim>::pre_refinement_action,
+ std_cxx11::ref(*this))));
tria_listeners.push_back
(tria.signals.post_refinement
- .connect (std_cxx1x::bind (&DoFHandler<dim,spacedim>::post_refinement_action,
- std_cxx1x::ref(*this))));
+ .connect (std_cxx11::bind (&DoFHandler<dim,spacedim>::post_refinement_action,
+ std_cxx11::ref(*this))));
tria_listeners.push_back
(tria.signals.create
- .connect (std_cxx1x::bind (&DoFHandler<dim,spacedim>::post_refinement_action,
- std_cxx1x::ref(*this))));
+ .connect (std_cxx11::bind (&DoFHandler<dim,spacedim>::post_refinement_action,
+ std_cxx11::ref(*this))));
}
// vertices at all, I can't think
// of a finite element that would
// make that necessary...
- Table<2,std_cxx1x::shared_ptr<dealii::internal::hp::DoFIdentities> >
+ Table<2,std_cxx11::shared_ptr<dealii::internal::hp::DoFIdentities> >
vertex_dof_identities (get_fe().size(),
get_fe().size());
// and then only deal with those that are
// not identical of which we can handle
// at most 2
- Table<2,std_cxx1x::shared_ptr<internal::hp::DoFIdentities> >
+ Table<2,std_cxx11::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_cxx1x::shared_ptr<internal::hp::DoFIdentities> >
+ Table<2,std_cxx11::shared_ptr<internal::hp::DoFIdentities> >
quad_dof_identities (finite_elements->size(),
finite_elements->size());
"same number of vector components!"));
finite_elements
- .push_back (std_cxx1x::shared_ptr<const FiniteElement<dim,spacedim> >(new_fe.clone()));
+ .push_back (std_cxx11::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_cxx1x::shared_ptr<FEValues>
+ std_cxx11::shared_ptr<FEValues>
(new FEValues ((*mapping_collection)[mapping_index],
(*fe_collection)[fe_index],
q_collection[q_index],
MappingCollection (const Mapping<dim,spacedim> &mapping)
{
mappings
- .push_back (std_cxx1x::shared_ptr<const Mapping<dim,spacedim> >(mapping.clone()));
+ .push_back (std_cxx11::shared_ptr<const Mapping<dim,spacedim> >(mapping.clone()));
}
MappingCollection<dim,spacedim>::push_back (const Mapping<dim,spacedim> &new_mapping)
{
mappings
- .push_back (std_cxx1x::shared_ptr<const Mapping<dim,spacedim> >(new_mapping.clone()));
+ .push_back (std_cxx11::shared_ptr<const Mapping<dim,spacedim> >(new_mapping.clone()));
}
//---------------------------------------------------------------------------
// 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_cxx1x::shared_ptr<Epetra_CrsGraph> graph;
+ std_cxx11::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));
Epetra_Map off_processor_map(-1, ghost_rows.size(), &ghost_rows[0],
0, input_row_map.Comm());
- std_cxx1x::shared_ptr<Epetra_CrsGraph> graph, nonlocal_graph;
+ std_cxx11::shared_ptr<Epetra_CrsGraph> graph, nonlocal_graph;
if (input_row_map.Comm().NumProc() > 1)
{
graph.reset (new Epetra_CrsGraph (Copy, input_row_map,
Epetra_Map new_map (v.size(), n_elements, &global_ids[0], 0,
v.block(0).vector_partitioner().Comm());
- std_cxx1x::shared_ptr<Epetra_FEVector> actual_vec;
+ std_cxx11::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_cxx1x::shared_ptr<BlockSparsityPattern> (new BlockSparsityPattern));
+ .push_back (std_cxx11::shared_ptr<BlockSparsityPattern> (new BlockSparsityPattern));
prolongation_matrices
- .push_back (std_cxx1x::shared_ptr<BlockSparseMatrix<double> > (new BlockSparseMatrix<double>));
+ .push_back (std_cxx11::shared_ptr<BlockSparseMatrix<double> > (new BlockSparseMatrix<double>));
}
// two fields which will store the
for (unsigned int i=0; i<n_levels-1; ++i)
{
prolongation_sparsities
- .push_back (std_cxx1x::shared_ptr<BlockSparsityPattern> (new BlockSparsityPattern));
+ .push_back (std_cxx11::shared_ptr<BlockSparsityPattern> (new BlockSparsityPattern));
prolongation_matrices
- .push_back (std_cxx1x::shared_ptr<BlockSparseMatrix<double> > (new BlockSparseMatrix<double>));
+ .push_back (std_cxx11::shared_ptr<BlockSparseMatrix<double> > (new BlockSparseMatrix<double>));
}
// two fields which will store the
for (unsigned int i=0; i<n_levels-1; ++i)
{
prolongation_sparsities.push_back
- (std_cxx1x::shared_ptr<typename internal::MatrixSelector<VECTOR>::Sparsity> (new typename internal::MatrixSelector<VECTOR>::Sparsity));
+ (std_cxx11::shared_ptr<typename internal::MatrixSelector<VECTOR>::Sparsity> (new typename internal::MatrixSelector<VECTOR>::Sparsity));
prolongation_matrices.push_back
- (std_cxx1x::shared_ptr<typename internal::MatrixSelector<VECTOR>::Matrix> (new typename internal::MatrixSelector<VECTOR>::Matrix));
+ (std_cxx11::shared_ptr<typename internal::MatrixSelector<VECTOR>::Matrix> (new typename internal::MatrixSelector<VECTOR>::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_cxx1x::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > &finite_elements,
+ const std::vector<std_cxx11::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_cxx1x::bind(&DataOut<dim,DH>::build_one_patch,
- this, std_cxx1x::_1, std_cxx1x::_2, std_cxx1x::_3,
- curved_cell_region,std_cxx1x::ref(this->patches)),
+ std_cxx11::bind(&DataOut<dim,DH>::build_one_patch,
+ this, std_cxx11::_1, std_cxx11::_2, std_cxx11::_3,
+ curved_cell_region,std_cxx11::ref(this->patches)),
// no copy-local-to-global function needed here
- std_cxx1x::function<void (const ::dealii::DataOutBase::Patch<DH::dimension, DH::space_dimension> &)>(),
+ std_cxx11::function<void (const ::dealii::DataOutBase::Patch<DH::dimension, DH::space_dimension> &)>(),
thread_data,
sample_patch,
// 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_cxx1x::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > &finite_elements,
+ const std::vector<std_cxx11::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > &finite_elements,
const UpdateFlags update_flags,
const bool use_face_values)
:
template <typename DH>
void
ParallelDataBase<dim,spacedim>::
- reinit_all_fe_values(std::vector<std_cxx1x::shared_ptr<DataEntryBase<DH> > > &dof_data,
+ reinit_all_fe_values(std::vector<std_cxx11::shared_ptr<DataEntryBase<DH> > > &dof_data,
const typename dealii::Triangulation<dim,spacedim>::cell_iterator &cell,
const unsigned int face)
{
= new internal::DataOut::DataEntry<DH,VECTOR>(dofs, &vec, names,
data_component_interpretation);
if (actual_type == type_dof_data)
- dof_data.push_back (std_cxx1x::shared_ptr<internal::DataOut::DataEntryBase<DH> >(new_entry));
+ dof_data.push_back (std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DH> >(new_entry));
else
- cell_data.push_back (std_cxx1x::shared_ptr<internal::DataOut::DataEntryBase<DH> >(new_entry));
+ cell_data.push_back (std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DH> >(new_entry));
}
internal::DataOut::DataEntryBase<DH> *new_entry
= new internal::DataOut::DataEntry<DH,VECTOR>(dofs, &vec, &data_postprocessor);
- dof_data.push_back (std_cxx1x::shared_ptr<internal::DataOut::DataEntryBase<DH> >(new_entry));
+ dof_data.push_back (std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DH> >(new_entry));
}
internal::DataOut::DataEntryBase<DH> *new_entry
= new internal::DataOut::DataEntry<DH,VECTOR>(&dof_handler, &vec, &data_postprocessor);
- dof_data.push_back (std_cxx1x::shared_ptr<internal::DataOut::DataEntryBase<DH> >(new_entry));
+ dof_data.push_back (std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DH> >(new_entry));
}
internal::DataOut::DataEntryBase<DH> *new_entry
= new internal::DataOut::DataEntry<DH,VECTOR>(&dof_handler, &data, names,
data_component_interpretation);
- dof_data.push_back (std_cxx1x::shared_ptr<internal::DataOut::DataEntryBase<DH> >(new_entry));
+ dof_data.push_back (std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DH> >(new_entry));
}
// collect the names of dof
// and cell data
typedef
- typename std::vector<std_cxx1x::shared_ptr<internal::DataOut::DataEntryBase<DH> > >::const_iterator
+ typename std::vector<std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DH> > >::const_iterator
data_iterator;
for (data_iterator d=dof_data.begin();
template <class DH,
int patch_dim, int patch_space_dim>
-std::vector<std_cxx1x::tuple<unsigned int, unsigned int, std::string> >
+std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> >
DataOut_DoFData<DH,patch_dim,patch_space_dim>::get_vector_data_ranges () const
{
- std::vector<std_cxx1x::tuple<unsigned int, unsigned int, std::string> >
+ std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> >
ranges;
// collect the ranges of dof
// and cell data
typedef
- typename std::vector<std_cxx1x::shared_ptr<internal::DataOut::DataEntryBase<DH> > >::const_iterator
+ typename std::vector<std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DH> > >::const_iterator
data_iterator;
unsigned int output_component = 0;
// finally add a corresponding
// range
- std_cxx1x::tuple<unsigned int, unsigned int, std::string>
+ std_cxx11::tuple<unsigned int, unsigned int, std::string>
range (output_component,
output_component+patch_space_dim-1,
name);
template <class DH,
int patch_dim, int patch_space_dim>
-std::vector<std_cxx1x::shared_ptr<dealii::hp::FECollection<DH::dimension,DH::space_dimension> > >
+std::vector<std_cxx11::shared_ptr<dealii::hp::FECollection<DH::dimension,DH::space_dimension> > >
DataOut_DoFData<DH,patch_dim,patch_space_dim>::get_finite_elements() const
{
const unsigned int dhdim = DH::dimension;
const unsigned int dhspacedim = DH::space_dimension;
- std::vector<std_cxx1x::shared_ptr<dealii::hp::FECollection<dhdim,dhspacedim> > >
+ std::vector<std_cxx11::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_cxx1x::shared_ptr<DataEntryBase<dealii::DH<deal_II_dimension,deal_II_space_dimension> > > > &dof_data,
+ (std::vector<std_cxx11::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_cxx1x::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > &finite_elements,
+ const std::vector<std_cxx11::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_cxx1x::bind(&DataOutFaces<dim,DH>::build_one_patch,
- this, std_cxx1x::_1, std_cxx1x::_2, std_cxx1x::_3),
- std_cxx1x::bind(&internal::DataOutFaces::
+ std_cxx11::bind(&DataOutFaces<dim,DH>::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_cxx1x::_1, std_cxx1x::ref(this->patches)),
+ std_cxx11::_1, std_cxx11::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_cxx1x::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > &finite_elements,
+ const std::vector<std_cxx11::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_cxx1x::bind(&DataOutRotation<dim,DH>::build_one_patch,
- this, std_cxx1x::_1, std_cxx1x::_2, std_cxx1x::_3),
- std_cxx1x::bind(&internal::DataOutRotation
+ std_cxx11::bind(&DataOutRotation<dim,DH>::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_cxx1x::_1, std_cxx1x::ref(this->patches)),
+ std_cxx11::_1, std_cxx11::ref(this->patches)),
thread_data,
new_patches);
}
template <class DerivativeDescription, int dim,
template <int, int> class DH, class InputVector, int spacedim>
void
- approximate (SynchronousIterators<std_cxx1x::tuple<typename DH<dim,spacedim>::active_cell_iterator,Vector<float>::iterator> > const &cell,
+ approximate (SynchronousIterators<std_cxx11::tuple<typename DH<dim,spacedim>::active_cell_iterator,Vector<float>::iterator> > const &cell,
const Mapping<dim,spacedim> &mapping,
const DH<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_cxx1x::get<0>(cell.iterators)->is_locally_owned() == false)
- *std_cxx1x::get<1>(cell.iterators) = 0;
+ if (std_cxx11::get<0>(cell.iterators)->is_locally_owned() == false)
+ *std_cxx11::get<1>(cell.iterators) = 0;
else
{
typename DerivativeDescription::Derivative derivative;
// call the function doing the actual
// work on this cell
approximate_cell<DerivativeDescription,dim,DH,InputVector>
- (mapping,dof_handler,solution,component,std_cxx1x::get<0>(cell.iterators),derivative);
+ (mapping,dof_handler,solution,component,std_cxx11::get<0>(cell.iterators),derivative);
// evaluate the norm and fill the vector
//*derivative_norm_on_this_cell
- *std_cxx1x::get<1>(cell.iterators) = DerivativeDescription::derivative_norm (derivative);
+ *std_cxx11::get<1>(cell.iterators) = DerivativeDescription::derivative_norm (derivative);
}
}
Assert (component < dof_handler.get_fe().n_components(),
ExcIndexRange (component, 0, dof_handler.get_fe().n_components()));
- typedef std_cxx1x::tuple<typename DH<dim,spacedim>::active_cell_iterator,Vector<float>::iterator>
+ typedef std_cxx11::tuple<typename DH<dim,spacedim>::active_cell_iterator,Vector<float>::iterator>
Iterators;
SynchronousIterators<Iterators> begin(Iterators(dof_handler.begin_active(),
derivative_norm.begin())),
// to write in derivative_norm. Scratch and CopyData are also useless.
WorkStream::run(begin,
end,
- static_cast<std_cxx1x::function<void (SynchronousIterators<Iterators> const &,
+ static_cast<std_cxx11::function<void (SynchronousIterators<Iterators> const &,
Assembler::Scratch const &, Assembler::CopyData &)> >
- (std_cxx1x::bind(&approximate<DerivativeDescription,dim,DH,InputVector,spacedim>,
- std_cxx1x::_1,
- std_cxx1x::cref(mapping),
- std_cxx1x::cref(dof_handler),
- std_cxx1x::cref(solution),component)),
- std_cxx1x::function<void (internal::Assembler::CopyData const &)> (),
+ (std_cxx11::bind(&approximate<DerivativeDescription,dim,DH,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 &)> (),
internal::Assembler::Scratch (),internal::Assembler::CopyData ());
}
#include <deal.II/hp/mapping_collection.h>
#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/base/std_cxx1x/bind.h>
+#include <deal.II/base/std_cxx11/bind.h>
#include <numeric>
#include <algorithm>
// now let's work on all those cells:
WorkStream::run (dof_handler.begin_active(),
static_cast<typename DH::active_cell_iterator>(dof_handler.end()),
- std_cxx1x::bind (&internal::estimate_one_cell<InputVector,DH>,
- std_cxx1x::_1, std_cxx1x::_2, std_cxx1x::_3, std_cxx1x::ref(solutions)),
- std_cxx1x::bind (&internal::copy_local_to_global<DH>,
- std_cxx1x::_1, std_cxx1x::ref(face_integrals)),
+ std_cxx11::bind (&internal::estimate_one_cell<InputVector,DH>,
+ std_cxx11::_1, std_cxx11::_2, std_cxx11::_3, std_cxx11::ref(solutions)),
+ std_cxx11::bind (&internal::copy_local_to_global<DH>,
+ std_cxx11::_1, std_cxx11::ref(face_integrals)),
parallel_data,
sample_local_face_integrals);
#include <deal.II/hp/mapping_collection.h>
#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/base/std_cxx1x/bind.h>
+#include <deal.II/base/std_cxx11/bind.h>
#include <numeric>
#include <algorithm>
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>,
- std_cxx1x::bind (&MatrixCreator::internal::
+ std_cxx11::bind (&MatrixCreator::internal::
copy_local_to_global<SparseMatrix<number>, Vector<double> >,
- std_cxx1x::_1, &matrix, (Vector<double> *)0),
+ std_cxx11::_1, &matrix, (Vector<double> *)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>,
- std_cxx1x::bind(&MatrixCreator::internal::
+ std_cxx11::bind(&MatrixCreator::internal::
copy_local_to_global<SparseMatrix<number>, Vector<double> >,
- std_cxx1x::_1, &matrix, &rhs_vector),
+ std_cxx11::_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>,
- std_cxx1x::bind (&MatrixCreator::internal::
+ std_cxx11::bind (&MatrixCreator::internal::
copy_local_to_global<SparseMatrix<number>, Vector<double> >,
- std_cxx1x::_1, &matrix, (Vector<double> *)0),
+ std_cxx11::_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::mass_assembler<dim, spacedim, typename hp::DoFHandler<dim,spacedim>::active_cell_iterator>,
- std_cxx1x::bind (&MatrixCreator::internal::
+ std_cxx11::bind (&MatrixCreator::internal::
copy_local_to_global<SparseMatrix<number>, Vector<double> >,
- std_cxx1x::_1, &matrix, &rhs_vector),
+ std_cxx11::_1, &matrix, &rhs_vector),
assembler_data,
copy_data);
}
MatrixCreator::internal::AssemblerBoundary::CopyData<DoFHandler<dim,spacedim> > copy_data;
WorkStream::run(dof.begin_active(),dof.end(),
- static_cast<std_cxx1x::function<void (typename DoFHandler<dim,spacedim>::active_cell_iterator
+ 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> > &)> >
- (std_cxx1x::bind(&create_boundary_mass_matrix_1<dim,spacedim>,std_cxx1x::_1,std_cxx1x::_2,
- std_cxx1x::_3,
- std_cxx1x::cref(mapping),std_cxx1x::cref(fe),std_cxx1x::cref(q),
- std_cxx1x::cref(boundary_functions),coefficient,
- std_cxx1x::cref(component_mapping))),
- static_cast<std_cxx1x::function<void (MatrixCreator::internal::AssemblerBoundary
- ::CopyData<DoFHandler<dim,spacedim> > const &)> > (std_cxx1x::bind(
+ (std_cxx11::bind(&create_boundary_mass_matrix_1<dim,spacedim>,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> > const &)> > (std_cxx11::bind(
©_boundary_mass_matrix_1<dim,spacedim>,
- std_cxx1x::_1,
- std_cxx1x::cref(boundary_functions),
- std_cxx1x::cref(dof_to_boundary_mapping),
- std_cxx1x::ref(matrix),
- std_cxx1x::ref(rhs_vector))),
+ std_cxx11::_1,
+ std_cxx11::cref(boundary_functions),
+ std_cxx11::cref(dof_to_boundary_mapping),
+ std_cxx11::ref(matrix),
+ std_cxx11::ref(rhs_vector))),
scratch,
copy_data);
}
MatrixCreator::internal::AssemblerBoundary::CopyData<hp::DoFHandler<dim,spacedim> > copy_data;
WorkStream::run(dof.begin_active(),dof.end(),
- static_cast<std_cxx1x::function<void (typename hp::DoFHandler<dim,spacedim>::active_cell_iterator
+ 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> > &)> >
- (std_cxx1x::bind( &create_hp_boundary_mass_matrix_1<dim,spacedim>,std_cxx1x::_1,std_cxx1x::_2,
- std_cxx1x::_3,
- std_cxx1x::cref(mapping),std_cxx1x::cref(fe_collection),std_cxx1x::cref(q),
- std_cxx1x::cref(boundary_functions),coefficient,
- std_cxx1x::cref(component_mapping))),
- static_cast<std_cxx1x::function<void (MatrixCreator::internal::AssemblerBoundary
+ (std_cxx11::bind( &create_hp_boundary_mass_matrix_1<dim,spacedim>,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> > const &)> > (
- std_cxx1x::bind( ©_hp_boundary_mass_matrix_1<dim,spacedim>,
- std_cxx1x::_1,
- std_cxx1x::cref(boundary_functions),
- std_cxx1x::cref(dof_to_boundary_mapping),
- std_cxx1x::ref(matrix),
- std_cxx1x::ref(rhs_vector))),
+ std_cxx11::bind( ©_hp_boundary_mass_matrix_1<dim,spacedim>,
+ std_cxx11::_1,
+ std_cxx11::cref(boundary_functions),
+ std_cxx11::cref(dof_to_boundary_mapping),
+ std_cxx11::ref(matrix),
+ std_cxx11::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_cxx1x::bind (&MatrixCreator::internal::
+ std_cxx11::bind (&MatrixCreator::internal::
copy_local_to_global<SparseMatrix<double>, Vector<double> >,
- std_cxx1x::_1,
+ std_cxx11::_1,
&matrix,
(Vector<double> *)NULL),
assembler_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_cxx1x::bind (&MatrixCreator::internal::
+ std_cxx11::bind (&MatrixCreator::internal::
copy_local_to_global<SparseMatrix<double>, Vector<double> >,
- std_cxx1x::_1,
+ std_cxx11::_1,
&matrix,
&rhs_vector),
assembler_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_cxx1x::bind (&MatrixCreator::internal::
+ std_cxx11::bind (&MatrixCreator::internal::
copy_local_to_global<SparseMatrix<double>, Vector<double> >,
- std_cxx1x::_1,
+ std_cxx11::_1,
&matrix,
(Vector<double> *)0),
assembler_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_cxx1x::bind (&MatrixCreator::internal::
+ std_cxx11::bind (&MatrixCreator::internal::
copy_local_to_global<SparseMatrix<double>, Vector<double> >,
- std_cxx1x::_1,
+ std_cxx11::_1,
&matrix,
&rhs_vector),
assembler_data,
= std::vector<std::vector <double> > (n_indep, std::vector <double> (0));
indep_names = std::vector <std::string> ();
- tria_listener = dof_handler.get_tria().signals.any_change.connect (std_cxx1x::bind (&PointValueHistory<dim>::tria_change_listener,
- std_cxx1x::ref(*this)));
+ tria_listener = dof_handler.get_tria().signals.any_change.connect (std_cxx11::bind (&PointValueHistory<dim>::tria_change_listener,
+ std_cxx11::ref(*this)));
}
// Presume subscribe new instance?
if (have_dof_handler)
{
- tria_listener = dof_handler->get_tria().signals.any_change.connect (std_cxx1x::bind (&PointValueHistory<dim>::tria_change_listener,
- std_cxx1x::ref(*this)));
+ tria_listener = dof_handler->get_tria().signals.any_change.connect (std_cxx11::bind (&PointValueHistory<dim>::tria_change_listener,
+ std_cxx11::ref(*this)));
}
}
// Presume subscribe new instance?
if (have_dof_handler)
{
- tria_listener = dof_handler->get_tria().signals.any_change.connect (std_cxx1x::bind (&PointValueHistory<dim>::tria_change_listener,
- std_cxx1x::ref(*this)));
+ tria_listener = dof_handler->get_tria().signals.any_change.connect (std_cxx11::bind (&PointValueHistory<dim>::tria_change_listener,
+ std_cxx11::ref(*this)));
}
return * this;
void (TimeDependent::*p) (const unsigned int, const unsigned int)
= &TimeDependent::end_sweep;
parallel::apply_to_subranges (0U, timesteps.size(),
- std_cxx1x::bind (p, this, std_cxx1x::_1, std_cxx1x::_2),
+ std_cxx11::bind (p, this, std_cxx11::_1, std_cxx11::_2),
1);
}
projects / dealii.git / commitdiff