* region, and release the old memory.
*/
void
- allocate_and_move(const size_t old_size,
- const size_t new_size,
- const size_t new_allocated_size);
+ allocate_and_move(const std::size_t old_size,
+ const std::size_t new_size,
+ const std::size_t new_allocated_size);
/**
* A class that is used as the "deleter" for a `std::unique_ptr` object that
template <class T>
inline void
-AlignedVector<T>::allocate_and_move(const size_t old_size,
- const size_t new_size,
- const size_t new_allocated_size)
+AlignedVector<T>::allocate_and_move(const std::size_t old_size,
+ const std::size_t new_size,
+ const std::size_t new_allocated_size)
{
// allocate and align along 64-byte boundaries (this is enough for all
// levels of vectorization currently supported by deal.II)
}
else
{
- return sizeof(char) * (strlen(string) /*Remember the NUL*/ + 1);
+ return sizeof(char) * (std::strlen(string) /*Remember the NUL*/ + 1);
}
}
template <typename T>
void
broadcast(T *buffer,
- const size_t count,
+ const std::size_t count,
const unsigned int root,
const MPI_Comm comm);
template <typename T>
void
broadcast(T *buffer,
- const size_t count,
+ const std::size_t count,
const unsigned int root,
const MPI_Comm comm)
{
};
- template <typename T, size_t width>
+ template <typename T, std::size_t width>
struct NaNInitializer<VectorizedArray<T, width>>
{
static VectorizedArray<T, width>
using iterator = typename Types<N, T, C>::iterator;
using const_iterator = typename Types<N, T, C>::const_iterator;
- using size_type = size_t;
- using difference_type = ptrdiff_t;
+ using size_type = std::size_t;
+ using difference_type = std::ptrdiff_t;
private:
/**
using reference = typename Types<N, T, C>::reference;
using const_reference = typename Types<N, T, C>::const_reference;
- using size_type = size_t;
- using difference_type = ptrdiff_t;
+ using size_type = std::size_t;
+ using difference_type = std::ptrdiff_t;
/**
* Import an alias from the switch class above.
* most common use cases for this function).
*/
template <typename T>
- size_t
+ std::size_t
pack(const T &object,
std::vector<char> &dest_buffer,
const bool allow_compression = true);
template <typename T>
- size_t
+ std::size_t
pack(const T &object,
std::vector<char> &dest_buffer,
const bool allow_compression)
operator-(const VectorizedArrayIterator<T> &other) const
{
return static_cast<std::ptrdiff_t>(lane) -
- static_cast<ptrdiff_t>(other.lane);
+ static_cast<std::ptrdiff_t>(other.lane);
}
private:
if (cell->face(face)->has_children() &&
!cell->face(face)->at_boundary())
{
- if (static_cast<uint8_t>(cell->face(face)->refinement_case()) ==
+ if (static_cast<std::uint8_t>(
+ cell->face(face)->refinement_case()) ==
RefinementCase<dim - 1>::isotropic_refinement)
{
Assert(cell->reference_cell() ==
AssertIndexRange(face_no, 5);
static const ndarray<Tensor<1, dim>, 5, 2> table = {
{{{Point<dim>(0, 1, 0), Point<dim>(1, 0, 0)}},
- {{Point<dim>(+1.0 / sqrt(2.0), 0, +1.0 / sqrt(2.0)),
+ {{Point<dim>(+1.0 / std::sqrt(2.0), 0, +1.0 / std::sqrt(2.0)),
Point<dim>(0, 1, 0)}},
- {{Point<dim>(+1.0 / sqrt(2.0), 0, -1.0 / sqrt(2.0)),
+ {{Point<dim>(+1.0 / std::sqrt(2.0), 0, -1.0 / std::sqrt(2.0)),
Point<dim>(0, 1, 0)}},
{{Point<dim>(1, 0, 0),
- Point<dim>(0, +1.0 / sqrt(2.0), +1.0 / sqrt(2.0))}},
+ Point<dim>(0, +1.0 / std::sqrt(2.0), +1.0 / std::sqrt(2.0))}},
{{Point<dim>(1, 0, 0),
- Point<dim>(0, +1.0 / sqrt(2.0), -1.0 / sqrt(2.0))}}}};
+ Point<dim>(0, +1.0 / std::sqrt(2.0), -1.0 / std::sqrt(2.0))}}}};
return table[face_no][i];
}
operator-(const CollectionIterator<T> &other) const
{
return static_cast<std::ptrdiff_t>(index) -
- static_cast<ptrdiff_t>(other.index);
+ static_cast<std::ptrdiff_t>(other.index);
}
private:
DeclException2(
ExcInvalidCharacter,
std::string,
- size_t,
+ std::size_t,
<< "Please use only the characters [a-zA-Z0-9_<>()] for" << std::endl
<< "description strings since some graphics formats will only accept these."
<< std::endl
/**
* Store the level we are currently visiting.
*/
- size_t level;
+ std::size_t level;
/**
* The level we want to extract from the RTree object.
*/
- const size_t target_level;
+ const std::size_t target_level;
/**
* A reference to the input vector of BoundingBox objects.
return;
}
- const size_t level_backup = level;
+ const std::size_t level_backup = level;
++level;
for (typename ElementsType::const_iterator it = elements.begin();
/**
* Store the level we are currently visiting.
*/
- size_t level;
+ std::size_t level;
/**
* Index used to keep track of the number of different visited nodes during
* recursion/
*/
- size_t node_counter;
+ std::size_t node_counter;
/**
* The level where children are living.
* Before: "we want to extract from the RTree object."
*/
- const size_t target_level;
+ const std::size_t target_level;
/**
* A reference to the input vector of vector of BoundingBox objects. This
return;
}
- size_t level_backup = level;
+ std::size_t level_backup = level;
++level;
for (typename elements_type::const_iterator it = elements.begin();
JobIdentifier::JobIdentifier()
{
- time_t t = std::time(nullptr);
- id = "JobId ";
+ std::time_t t = std::time(nullptr);
+ id = "JobId ";
#if defined(DEAL_II_HAVE_UNISTD_H) && defined(DEAL_II_HAVE_GETHOSTNAME)
char name[100];
Vector<Number> tmp(criteria);
if (refine_cells)
{
- if (static_cast<size_t>(refine_cells) == criteria.size())
+ if (static_cast<std::size_t>(refine_cells) == criteria.size())
refine(tria, criteria, std::numeric_limits<double>::lowest());
else
{
if (coarsen_cells)
{
- if (static_cast<size_t>(coarsen_cells) == criteria.size())
+ if (static_cast<std::size_t>(coarsen_cells) == criteria.size())
coarsen(tria, criteria, std::numeric_limits<double>::max());
else
{
// Allocate sufficient memory.
const unsigned int bytes_per_cell = sizes_fixed_cumulative.back();
- dest_data_fixed.resize(static_cast<size_t>(local_num_cells) *
+ dest_data_fixed.resize(static_cast<std::size_t>(local_num_cells) *
bytes_per_cell);
// Read packed data from file simultaneously.
sizes_fixed_cumulative.size() * sizeof(unsigned int));
const unsigned int bytes_per_cell = sizes_fixed_cumulative.back();
- dest_data_fixed.resize(static_cast<size_t>(local_num_cells) *
+ dest_data_fixed.resize(static_cast<std::size_t>(local_num_cells) *
bytes_per_cell);
// Read packed data.
{
// if we are asked to visit the past-the-end line, then simply
// release all our caches and go on with life
- if (static_cast<size_t>(this->a_row) == sparsity_pattern->n_rows())
+ if (static_cast<std::size_t>(this->a_row) == sparsity_pattern->n_rows())
{
colnum_cache.reset();
return;
trilinos_j) -
col_indices.data();
- return static_cast<size_t>(local_col_index) != col_indices.size();
+ return static_cast<std::size_t>(local_col_index) != col_indices.size();
# else
(void)i;
(void)j;