} // namespace internal
// --------------------------------------------------------------
- template <size_t N>
+ template <std::size_t N>
struct make_index_sequence : internal::merge_and_renumber<
typename make_index_sequence<N / 2>::type,
typename make_index_sequence<N - N / 2>::type>
* leaving this task to the calling site.
*/
void
- posix_memalign(void **memptr, size_t alignment, size_t size);
+ posix_memalign(void **memptr, std::size_t alignment, std::size_t size);
} // namespace System
// the data is never compressed when we can't use zlib.
(void)allow_compression;
- size_t size = 0;
+ std::size_t size = 0;
// see if the object is small and copyable via memcpy. if so, use
// this fast path. otherwise, we have to go through the BOOST
# endif
#endif
{
- const size_t previous_size = dest_buffer.size();
+ const std::size_t previous_size = dest_buffer.size();
dest_buffer.resize(previous_size + sizeof(T));
std::memcpy(dest_buffer.data() + previous_size, &object, sizeof(T));
{
// use buffer as the target of a compressing
// stream into which we serialize the current object
- const size_t previous_size = dest_buffer.size();
+ const std::size_t previous_size = dest_buffer.size();
#ifdef DEAL_II_WITH_ZLIB
if (allow_compression)
{
* Access to the D-th coordinate of the lower left corner of a
* dealii::BoundingBox.
*/
- template <int dim, class Number, size_t D>
+ template <int dim, class Number, std::size_t D>
struct indexed_access<dealii::BoundingBox<dim, Number>, min_corner, D>
{
/**
* Access to the D-th coordinate of the upper right corner of a
* dealii::BoundingBox.
*/
- template <int dim, class Number, size_t D>
+ template <int dim, class Number, std::size_t D>
struct indexed_access<dealii::BoundingBox<dim, Number>, max_corner, D>
{
/**
/**
* Getter function for D-th coordinate of a dealii Point.
*/
- template <size_t D, int dim, class Number>
+ template <std::size_t D, int dim, class Number>
struct access<dealii::Point<dim, Number>, D>
{
static inline double
types<2>::locidx min_quadrants,
int min_level,
int fill_uniform,
- size_t data_size,
+ std::size_t data_size,
p4est_init_t init_fn,
void * user_pointer);
static types<2>::forest *(&load_ext)(const char *filename,
MPI_Comm mpicomm,
- size_t data_size,
+ std::size_t data_size,
int load_data,
int autopartition,
int broadcasthead,
static int (&connectivity_is_valid)(types<2>::connectivity *connectivity);
- static types<2>::connectivity *(&connectivity_load)(const char *filename,
- size_t * length);
+ static types<2>::connectivity *(&connectivity_load)(const char * filename,
+ std::size_t *length);
static unsigned int (&checksum)(types<2>::forest *p4est);
static void (&ghost_destroy)(types<2>::ghost *ghost);
static void (&reset_data)(types<2>::forest *p4est,
- size_t data_size,
+ std::size_t data_size,
p4est_init_t init_fn,
void * user_pointer);
- static size_t (&forest_memory_used)(types<2>::forest *p4est);
+ static std::size_t (&forest_memory_used)(types<2>::forest *p4est);
- static size_t (&connectivity_memory_used)(types<2>::connectivity *p4est);
+ static std::size_t (&connectivity_memory_used)(
+ types<2>::connectivity *p4est);
template <int spacedim>
static void
int tag,
void * dest_data,
const void * src_data,
- size_t data_size);
+ std::size_t data_size);
static types<2>::transfer_context *(&transfer_fixed_begin)(
const types<2>::gloidx *dest_gfq,
int tag,
void * dest_data,
const void * src_data,
- size_t data_size);
+ std::size_t data_size);
static void (&transfer_fixed_end)(types<2>::transfer_context *tc);
types<3>::locidx min_quadrants,
int min_level,
int fill_uniform,
- size_t data_size,
+ std::size_t data_size,
p8est_init_t init_fn,
void * user_pointer);
static int (&connectivity_is_valid)(types<3>::connectivity *connectivity);
- static types<3>::connectivity *(&connectivity_load)(const char *filename,
- size_t * length);
+ static types<3>::connectivity *(&connectivity_load)(const char * filename,
+ std::size_t *length);
static unsigned int (&checksum)(types<3>::forest *p8est);
static void (&ghost_destroy)(types<3>::ghost *ghost);
static void (&reset_data)(types<3>::forest *p4est,
- size_t data_size,
+ std::size_t data_size,
p8est_init_t init_fn,
void * user_pointer);
- static size_t (&forest_memory_used)(types<3>::forest *p4est);
+ static std::size_t (&forest_memory_used)(types<3>::forest *p4est);
- static size_t (&connectivity_memory_used)(types<3>::connectivity *p4est);
+ static std::size_t (&connectivity_memory_used)(
+ types<3>::connectivity *p4est);
static constexpr unsigned int max_level = P8EST_MAXLEVEL;
int tag,
void * dest_data,
const void * src_data,
- size_t data_size);
+ std::size_t data_size);
static types<3>::transfer_context *(&transfer_fixed_begin)(
const types<3>::gloidx *dest_gfq,
int tag,
void * dest_data,
const void * src_data,
- size_t data_size);
+ std::size_t data_size);
static void (&transfer_fixed_end)(types<3>::transfer_context *tc);
Assert(cell_ids.size() == data.size(),
ExcDimensionMismatch(cell_ids.size(), data.size()));
// archive the cellids in an efficient binary format
- const size_t n_cells = cell_ids.size();
- ar & n_cells;
+ const std::size_t n_cells = cell_ids.size();
+ ar & n_cells;
for (auto &it : cell_ids)
{
CellId::binary_type binary_cell_id = it.template to_binary<dim>();
CellDataTransferBuffer<dim, T>::load(Archive &ar,
const unsigned int /*version*/)
{
- size_t n_cells;
- ar & n_cells;
+ std::size_t n_cells;
+ ar & n_cells;
cell_ids.clear();
cell_ids.reserve(n_cells);
for (unsigned int c = 0; c < n_cells; ++c)
BlockLinearOperator<Range, Domain, BlockPayload>
block_operator(const BlockMatrixType &matrix);
-template <size_t m,
- size_t n,
+template <std::size_t m,
+ std::size_t n,
typename Range = BlockVector<double>,
typename Domain = Range,
typename BlockPayload =
n>,
m> &);
-template <size_t m,
+template <std::size_t m,
typename Range = BlockVector<double>,
typename Domain = Range,
typename BlockPayload =
typename BlockPayload::BlockType>,
m> &);
-template <size_t m,
+template <std::size_t m,
typename Range = BlockVector<double>,
typename Domain = Range,
typename BlockPayload =
* LinearOperator. This constructor calls the corresponding block_operator()
* specialization.
*/
- template <size_t m, size_t n>
+ template <std::size_t m, std::size_t n>
BlockLinearOperator(const std::array<std::array<BlockType, n>, m> &ops)
{
*this = block_operator<m, n, Range, Domain, BlockPayload>(ops);
* @p ops of LinearOperator. This constructor calls the corresponding
* block_operator() specialization.
*/
- template <size_t m>
+ template <std::size_t m>
BlockLinearOperator(const std::array<BlockType, m> &ops)
{
*this = block_diagonal_operator<m, Range, Domain, BlockPayload>(ops);
* This assignment operator calls the corresponding block_operator()
* specialization.
*/
- template <size_t m, size_t n>
+ template <std::size_t m, std::size_t n>
BlockLinearOperator<Range, Domain, BlockPayload> &
operator=(const std::array<std::array<BlockType, n>, m> &ops)
{
* that creates a block-diagonal BlockLinearOperator. This assignment
* operator calls the corresponding block_operator() specialization.
*/
- template <size_t m>
+ template <std::size_t m>
BlockLinearOperator<Range, Domain, BlockPayload> &
operator=(const std::array<BlockType, m> &ops)
{
*
* @ingroup LAOperators
*/
-template <size_t m,
- size_t n,
+template <std::size_t m,
+ std::size_t n,
typename Range,
typename Domain,
typename BlockPayload>
*
* @ingroup LAOperators
*/
-template <size_t m, typename Range, typename Domain, typename BlockPayload>
+template <std::size_t m, typename Range, typename Domain, typename BlockPayload>
BlockLinearOperator<Range, Domain, BlockPayload>
block_diagonal_operator(
const std::array<LinearOperator<typename Range::BlockType,
*
* @ingroup LAOperators
*/
-template <size_t m, typename Range, typename Domain, typename BlockPayload>
+template <std::size_t m, typename Range, typename Domain, typename BlockPayload>
BlockLinearOperator<Range, Domain, BlockPayload>
block_diagonal_operator(
const LinearOperator<typename Range::BlockType,
{
Assert(!this->empty(), ExcEmptyMatrix());
- for (size_t l = 0; l < m(); ++l)
+ for (std::size_t l = 0; l < m(); ++l)
(*this)(l, i) += s * (*this)(l, j) + t * (*this)(l, k);
}
Assert(dst.size() == n(), ExcDimensionMismatch(dst.size(), n()));
Assert(src.size() == n(), ExcDimensionMismatch(src.size(), n()));
- const size_t n = src.size();
+ const std::size_t n = src.size();
somenumber * dst_ptr = dst.begin();
const somenumber *src_ptr = src.begin();
*
* @ingroup TrilinosWrappers
*/
- template <size_t m, size_t n, typename Range, typename Domain = Range>
+ template <std::size_t m,
+ std::size_t n,
+ typename Range,
+ typename Domain = Range>
inline BlockLinearOperator<
Range,
Domain,
*
* @ingroup TrilinosWrappers
*/
- template <size_t m, typename Range, typename Domain = Range>
+ template <std::size_t m, typename Range, typename Domain = Range>
inline BlockLinearOperator<
Range,
Domain,
* Return the L2 distance between points
*/
coord_t
- kdtree_distance(const coord_t *p1,
- const size_t idx_p2,
- const size_t size) const;
+ kdtree_distance(const coord_t * p1,
+ const std::size_t idx_p2,
+ const std::size_t size) const;
/**
* Return the d-th component of the idx-th point in the class.
*/
coord_t
- kdtree_get_pt(const size_t idx, const int d) const;
+ kdtree_get_pt(const std::size_t idx, const int d) const;
/**
template <int dim>
inline double
-KDTree<dim>::PointCloudAdaptor::kdtree_get_pt(const size_t idx, int d) const
+KDTree<dim>::PointCloudAdaptor::kdtree_get_pt(const std::size_t idx,
+ int d) const
{
AssertIndexRange(d, dim);
return points[idx][d];
template <int dim>
inline double
-KDTree<dim>::PointCloudAdaptor::kdtree_distance(const double *p1,
- const size_t idx_p2,
- const size_t size) const
+KDTree<dim>::PointCloudAdaptor::kdtree_distance(const double * p1,
+ const std::size_t idx_p2,
+ const std::size_t size) const
{
AssertDimension(size, dim);
double res = 0.0;
- for (size_t d = 0; d < size; ++d)
+ for (std::size_t d = 0; d < size; ++d)
res += (p1[d] - points[idx_p2][d]) * (p1[d] - points[idx_p2][d]);
return std::sqrt(res);
}
AssertThrow(out, ExcIO());
out.write(reinterpret_cast<const char *>(&index_space_size),
sizeof(index_space_size));
- size_t n_ranges = ranges.size();
+ std::size_t n_ranges = ranges.size();
out.write(reinterpret_cast<const char *>(&n_ranges), sizeof(n_ranges));
if (ranges.empty() == false)
out.write(reinterpret_cast<const char *>(&*ranges.begin()),
void
IndexSet::block_read(std::istream &in)
{
- size_type size;
- size_t n_ranges;
+ size_type size;
+ std::size_t n_ranges;
in.read(reinterpret_cast<char *>(&size), sizeof(size));
in.read(reinterpret_cast<char *>(&n_ranges), sizeof(n_ranges));
// we have to clear ranges first
unsigned int
MultithreadInfo::get_n_cpus()
{
- int mib[2];
- int n_cpus;
- size_t len;
+ int mib[2];
+ int n_cpus;
+ std::size_t len;
mib[0] = CTL_HW;
mib[1] = HW_NCPU;
void
- posix_memalign(void **memptr, size_t alignment, size_t size)
+ posix_memalign(void **memptr, std::size_t alignment, std::size_t size)
{
#ifndef DEAL_II_MSVC
const int ierr = ::posix_memalign(memptr, alignment, size);
types<2>::locidx min_quadrants,
int min_level,
int fill_uniform,
- size_t data_size,
+ std::size_t data_size,
p4est_init_t init_fn,
void * user_pointer) = p4est_new_ext;
types<2>::connectivity *connectivity) = p4est_connectivity_is_valid;
types<2>::connectivity *(&functions<2>::connectivity_load)(
- const char *filename,
- size_t * length) = p4est_connectivity_load;
+ const char * filename,
+ std::size_t *length) = p4est_connectivity_load;
unsigned int (&functions<2>::checksum)(types<2>::forest *p4est) =
p4est_checksum;
p4est_ghost_destroy;
void (&functions<2>::reset_data)(types<2>::forest *p4est,
- size_t data_size,
+ std::size_t data_size,
p4est_init_t init_fn,
void *user_pointer) = p4est_reset_data;
- size_t (&functions<2>::forest_memory_used)(types<2>::forest *p4est) =
+ std::size_t (&functions<2>::forest_memory_used)(types<2>::forest *p4est) =
p4est_memory_used;
- size_t (&functions<2>::connectivity_memory_used)(
+ std::size_t (&functions<2>::connectivity_memory_used)(
types<2>::connectivity *p4est) = p4est_connectivity_memory_used;
template <int dim, int spacedim>
int tag,
void * dest_data,
const void * src_data,
- size_t data_size) =
+ std::size_t data_size) =
p4est_transfer_fixed;
types<2>::transfer_context *(&functions<2>::transfer_fixed_begin)(
int tag,
void * dest_data,
const void * src_data,
- size_t data_size) = p4est_transfer_fixed_begin;
+ std::size_t data_size) = p4est_transfer_fixed_begin;
void (&functions<2>::transfer_fixed_end)(types<2>::transfer_context *tc) =
p4est_transfer_fixed_end;
types<3>::locidx min_quadrants,
int min_level,
int fill_uniform,
- size_t data_size,
+ std::size_t data_size,
p8est_init_t init_fn,
void * user_pointer) = p8est_new_ext;
types<3>::connectivity *connectivity) = p8est_connectivity_is_valid;
types<3>::connectivity *(&functions<3>::connectivity_load)(
- const char *filename,
- size_t * length) = p8est_connectivity_load;
+ const char * filename,
+ std::size_t *length) = p8est_connectivity_load;
unsigned int (&functions<3>::checksum)(types<3>::forest *p8est) =
p8est_checksum;
p8est_ghost_destroy;
void (&functions<3>::reset_data)(types<3>::forest *p4est,
- size_t data_size,
+ std::size_t data_size,
p8est_init_t init_fn,
void *user_pointer) = p8est_reset_data;
- size_t (&functions<3>::forest_memory_used)(types<3>::forest *p4est) =
+ std::size_t (&functions<3>::forest_memory_used)(types<3>::forest *p4est) =
p8est_memory_used;
- size_t (&functions<3>::connectivity_memory_used)(
+ std::size_t (&functions<3>::connectivity_memory_used)(
types<3>::connectivity *p4est) = p8est_connectivity_memory_used;
constexpr unsigned int functions<3>::max_level;
int tag,
void * dest_data,
const void * src_data,
- size_t data_size) =
+ std::size_t data_size) =
p8est_transfer_fixed;
types<3>::transfer_context *(&functions<3>::transfer_fixed_begin)(
int tag,
void * dest_data,
const void * src_data,
- size_t data_size) = p8est_transfer_fixed_begin;
+ std::size_t data_size) = p8est_transfer_fixed_begin;
void (&functions<3>::transfer_fixed_end)(types<3>::transfer_context *tc) =
p8est_transfer_fixed_end;
copy_data.global_parameter_representation.resize(n_interesting_dofs);
bool is_called_in_parallel = false;
- for (size_t i = 0; i < copy_data.global_parameter_representation.size();
+ for (std::size_t i = 0;
+ i < copy_data.global_parameter_representation.size();
++i)
{
#ifdef DEAL_II_WITH_MPI
copy_data);
#ifdef DEAL_II_WITH_MPI
- for (size_t i = 0; i < copy_data.global_parameter_representation.size();
+ for (std::size_t i = 0;
+ i < copy_data.global_parameter_representation.size();
++i)
copy_data.global_parameter_representation[i].update_ghost_values();
#endif
n_locally_owned_mg_dofs_per_processor(
locally_owned_mg_dofs_per_processor.size(), 0);
- for (size_t index = 0;
+ for (std::size_t index = 0;
index < n_locally_owned_mg_dofs_per_processor.size();
++index)
{
# ifdef DEAL_II_WITH_MPI
if (is_serial_vector<VectorType>::value == false)
{
- const IndexSet is = solution.locally_owned_elements();
- const size_t local_system_size = is.n_elements();
+ const IndexSet is = solution.locally_owned_elements();
+ const std::size_t local_system_size = is.n_elements();
yy = N_VNew_Parallel(communicator, local_system_size, system_size);
# ifdef DEAL_II_WITH_MPI
if (is_serial_vector<VectorType>::value == false)
{
- const IndexSet is = solution.locally_owned_elements();
- const size_t local_system_size = is.n_elements();
+ const IndexSet is = solution.locally_owned_elements();
+ const std::size_t local_system_size = is.n_elements();
yy = N_VNew_Parallel(communicator, local_system_size, system_size);
void
copy(TrilinosWrappers::MPI::Vector &dst, const N_Vector &src)
{
- const IndexSet is = dst.locally_owned_elements();
- const size_t N = is.n_elements();
+ const IndexSet is = dst.locally_owned_elements();
+ const std::size_t N = is.n_elements();
AssertDimension(N, N_Vector_length(src));
- for (size_t i = 0; i < N; ++i)
+ for (std::size_t i = 0; i < N; ++i)
{
dst[is.nth_index_in_set(i)] = NV_Ith_P(src, i);
}
void
copy(N_Vector &dst, const TrilinosWrappers::MPI::Vector &src)
{
- const IndexSet is = src.locally_owned_elements();
- const size_t N = is.n_elements();
+ const IndexSet is = src.locally_owned_elements();
+ const std::size_t N = is.n_elements();
AssertDimension(N, N_Vector_length(dst));
- for (size_t i = 0; i < N; ++i)
+ for (std::size_t i = 0; i < N; ++i)
{
NV_Ith_P(dst, i) = src[is.nth_index_in_set(i)];
}
void
copy(TrilinosWrappers::MPI::BlockVector &dst, const N_Vector &src)
{
- const IndexSet is = dst.locally_owned_elements();
- const size_t N = is.n_elements();
+ const IndexSet is = dst.locally_owned_elements();
+ const std::size_t N = is.n_elements();
AssertDimension(N, N_Vector_length(src));
- for (size_t i = 0; i < N; ++i)
+ for (std::size_t i = 0; i < N; ++i)
{
dst[is.nth_index_in_set(i)] = NV_Ith_P(src, i);
}
void
copy(N_Vector &dst, const TrilinosWrappers::MPI::BlockVector &src)
{
- IndexSet is = src.locally_owned_elements();
- const size_t N = is.n_elements();
+ IndexSet is = src.locally_owned_elements();
+ const std::size_t N = is.n_elements();
AssertDimension(N, N_Vector_length(dst));
- for (size_t i = 0; i < N; ++i)
+ for (std::size_t i = 0; i < N; ++i)
{
NV_Ith_P(dst, i) = src[is.nth_index_in_set(i)];
}
void
copy(PETScWrappers::MPI::Vector &dst, const N_Vector &src)
{
- const IndexSet is = dst.locally_owned_elements();
- const size_t N = is.n_elements();
+ const IndexSet is = dst.locally_owned_elements();
+ const std::size_t N = is.n_elements();
AssertDimension(N, N_Vector_length(src));
- for (size_t i = 0; i < N; ++i)
+ for (std::size_t i = 0; i < N; ++i)
{
dst[is.nth_index_in_set(i)] = NV_Ith_P(src, i);
}
void
copy(N_Vector &dst, const PETScWrappers::MPI::Vector &src)
{
- const IndexSet is = src.locally_owned_elements();
- const size_t N = is.n_elements();
+ const IndexSet is = src.locally_owned_elements();
+ const std::size_t N = is.n_elements();
AssertDimension(N, N_Vector_length(dst));
- for (size_t i = 0; i < N; ++i)
+ for (std::size_t i = 0; i < N; ++i)
{
NV_Ith_P(dst, i) = src[is.nth_index_in_set(i)];
}
void
copy(PETScWrappers::MPI::BlockVector &dst, const N_Vector &src)
{
- const IndexSet is = dst.locally_owned_elements();
- const size_t N = is.n_elements();
+ const IndexSet is = dst.locally_owned_elements();
+ const std::size_t N = is.n_elements();
AssertDimension(N, N_Vector_length(src));
- for (size_t i = 0; i < N; ++i)
+ for (std::size_t i = 0; i < N; ++i)
{
dst[is.nth_index_in_set(i)] = NV_Ith_P(src, i);
}
void
copy(N_Vector &dst, const PETScWrappers::MPI::BlockVector &src)
{
- const IndexSet is = src.locally_owned_elements();
- const size_t N = is.n_elements();
+ const IndexSet is = src.locally_owned_elements();
+ const std::size_t N = is.n_elements();
AssertDimension(N, N_Vector_length(dst));
- for (size_t i = 0; i < N; ++i)
+ for (std::size_t i = 0; i < N; ++i)
{
NV_Ith_P(dst, i) = src[is.nth_index_in_set(i)];
}
void
copy(BlockVector<double> &dst, const N_Vector &src)
{
- const size_t N = dst.size();
+ const std::size_t N = dst.size();
AssertDimension(N_Vector_length(src), N);
- for (size_t i = 0; i < N; ++i)
+ for (std::size_t i = 0; i < N; ++i)
{
dst[i] = NV_Ith_S(src, i);
}
void
copy(N_Vector &dst, const BlockVector<double> &src)
{
- const size_t N = src.size();
+ const std::size_t N = src.size();
AssertDimension(N_Vector_length(dst), N);
- for (size_t i = 0; i < N; ++i)
+ for (std::size_t i = 0; i < N; ++i)
{
NV_Ith_S(dst, i) = src[i];
}
void
copy(Vector<double> &dst, const N_Vector &src)
{
- const size_t N = dst.size();
+ const std::size_t N = dst.size();
AssertDimension(N_Vector_length(src), N);
- for (size_t i = 0; i < N; ++i)
+ for (std::size_t i = 0; i < N; ++i)
{
dst[i] = NV_Ith_S(src, i);
}
void
copy(N_Vector &dst, const Vector<double> &src)
{
- const size_t N = src.size();
+ const std::size_t N = src.size();
AssertDimension(N_Vector_length(dst), N);
- for (size_t i = 0; i < N; ++i)
+ for (std::size_t i = 0; i < N; ++i)
{
NV_Ith_S(dst, i) = src[i];
}
# ifdef DEAL_II_WITH_MPI
if (is_serial_vector<VectorType>::value == false)
{
- const IndexSet is = solution.locally_owned_elements();
- const size_t local_system_size = is.n_elements();
+ const IndexSet is = solution.locally_owned_elements();
+ const std::size_t local_system_size = is.n_elements();
yy = N_VNew_Parallel(communicator, local_system_size, system_size);
# ifdef DEAL_II_WITH_MPI
if (is_serial_vector<VectorType>::value == false)
{
- const IndexSet is = solution.locally_owned_elements();
- const size_t local_system_size = is.n_elements();
+ const IndexSet is = solution.locally_owned_elements();
+ const std::size_t local_system_size = is.n_elements();
yy = N_VNew_Parallel(communicator, local_system_size, system_size);
// PACK BUFFER
// add first object to buffer and store buffer size for later separation
- const size_t buffer_separator = Utilities::pack(array, buffer);
+ const std::size_t buffer_separator = Utilities::pack(array, buffer);
// add second object to buffer
Utilities::pack(point, buffer);
// For this test case, all weights are one and their sum
// should be equal to number of degrees of freedom
unsigned local_sum = 0.;
- for (size_t i = 0; i < transfer_representation.size(); ++i)
+ for (std::size_t i = 0; i < transfer_representation.size(); ++i)
{
TransferRep::value_type m = transfer_representation[i];
for (TransferRep::value_type::const_iterator it = m.begin();
// Creating the random points
std::vector<Point<dim>> points;
- for (size_t i = 0; i < n_points; ++i)
+ for (std::size_t i = 0; i < n_points; ++i)
points.push_back(random_point<dim>());
std::vector<typename DoFHandler<dim>::active_cell_iterator> cells;
Vector<double> dummy;
Functions::FEFieldFunction<dim> fe_function(
dof_handler, dummy, StaticMappingQ1<dim, dim>::mapping);
- size_t n_cells =
+ std::size_t n_cells =
fe_function.compute_point_locations(points, cells, qpoints, maps);
deallog << "Points found in " << n_cells << " cells" << std::endl;
{
initlog();
- size_t m = 2, n = 3;
+ std::size_t m = 2, n = 3;
FullMatrix<double> A(m, n);
- for (size_t i = 0; i < m; ++i)
- for (size_t j = 0; j < n; ++j)
+ for (std::size_t i = 0; i < m; ++i)
+ for (std::size_t j = 0; j < n; ++j)
A(i, j) = n * i + j;
deallog << "Size of A:" << std::endl << A.m() << " " << A.n() << std::endl;
// Creating the random points
std::vector<Point<dim>> points;
- for (size_t i = 0; i < n_points; ++i)
+ for (std::size_t i = 0; i < n_points; ++i)
points.push_back(random_point<dim>());
// Initializing the cache
GridTools::Cache<dim, dim> cache(tria);
- auto cell_qpoint_map = GridTools::compute_point_locations(cache, points);
- size_t n_cells = std::get<0>(cell_qpoint_map).size();
+ auto cell_qpoint_map = GridTools::compute_point_locations(cache, points);
+ std::size_t n_cells = std::get<0>(cell_qpoint_map).size();
deallog << "Points found in " << n_cells << " cells" << std::endl;
// Creating the random points
std::vector<Point<dim>> points;
- for (size_t i = 0; i < n_points; ++i)
+ for (std::size_t i = 0; i < n_points; ++i)
{
Point<dim> p;
for (unsigned int d = 0; d < dim; ++d)
auto my_pair = GridTools::find_active_cell_around_point(cache, points[0]);
auto cell_qpoint_map =
GridTools::compute_point_locations(cache, points, my_pair.first);
- size_t n_cells = std::get<0>(cell_qpoint_map).size();
+ std::size_t n_cells = std::get<0>(cell_qpoint_map).size();
deallog << "Points found in " << n_cells << " cells" << std::endl;
// Creating the random points
std::vector<Point<dim>> points;
- for (size_t i = 0; i < n_points; ++i)
+ for (std::size_t i = 0; i < n_points; ++i)
points.push_back(random_point<dim>());
// Initializing the cache
// Testing in serial against the serial version
auto cell_qpoint_map = GridTools::compute_point_locations(cache, points);
- auto & serial_cells = std::get<0>(cell_qpoint_map);
- auto & serial_qpoints = std::get<1>(cell_qpoint_map);
- size_t n_cells = std::get<0>(output_tuple).size();
+ auto & serial_cells = std::get<0>(cell_qpoint_map);
+ auto & serial_qpoints = std::get<1>(cell_qpoint_map);
+ std::size_t n_cells = std::get<0>(output_tuple).size();
deallog << "Points found in " << n_cells << " cells" << std::endl;
std::vector<Point<spacedim>> points;
deallog << "Points in study: " << n_points << std::endl;
- for (size_t i = 0; i < n_points; ++i)
+ for (std::size_t i = 0; i < n_points; ++i)
points.push_back(random_point<spacedim>());
auto v_to_c = GridTools::vertex_to_cell_map(tria);
std::vector<Point<spacedim>> points;
deallog << "Points in study: " << n_points << std::endl;
- for (size_t i = 0; i < n_points; ++i)
+ for (std::size_t i = 0; i < n_points; ++i)
points.push_back(random_point<spacedim>());
auto &mapping = StaticMappingQ1<dim, spacedim>::mapping;
points.clear();
unsigned int n_points = 2 * tot_bbox;
- for (size_t i = 0; i < n_points; ++i)
+ for (std::size_t i = 0; i < n_points; ++i)
{
Point<spacedim> p;
p[0] = tot_bbox * double(Testing::rand()) / RAND_MAX;
const std::vector<std::pair<types::global_dof_index, double>> &c2 =
*constraints_fe.get_constraint_entries(lines.nth_index_in_set(i));
- for (size_t j = 0; j < c1.size(); ++j)
+ for (std::size_t j = 0; j < c1.size(); ++j)
if ((c1[j].first != c2[j].first) ||
(fabs(c1[j].second - c2[j].second) > 1e-14))
{
projects / dealii.git / commitdiff