* the new value does not conform to the pattern for this entry.
*/
void
- set(const std::string &entry_name, const double &new_value);
+ set(const std::string &entry_name, const double new_value);
/**
* Change the value presently stored for <tt>entry_name</tt> to the one
* @relatesalso VectorizedArray
*/
inline DEAL_II_ALWAYS_INLINE VectorizedArray<float>
- operator+(const double &u, const VectorizedArray<float> &v)
+ operator+(const double u, const VectorizedArray<float> &v)
{
VectorizedArray<float> tmp;
tmp = u;
* @relatesalso VectorizedArray
*/
inline DEAL_II_ALWAYS_INLINE VectorizedArray<float>
- operator+(const VectorizedArray<float> &v, const double &u)
+ operator+(const VectorizedArray<float> &v, const double u)
{
return u + v;
}
* @relatesalso VectorizedArray
*/
inline DEAL_II_ALWAYS_INLINE VectorizedArray<float>
- operator-(const double &u, const VectorizedArray<float> &v)
+ operator-(const double u, const VectorizedArray<float> &v)
{
VectorizedArray<float> tmp;
tmp = float(u);
* @relatesalso VectorizedArray
*/
inline DEAL_II_ALWAYS_INLINE VectorizedArray<float>
- operator-(const VectorizedArray<float> &v, const double &u)
+ operator-(const VectorizedArray<float> &v, const double u)
{
VectorizedArray<float> tmp;
tmp = float(u);
* @relatesalso VectorizedArray
*/
inline DEAL_II_ALWAYS_INLINE VectorizedArray<float>
- operator*(const double &u, const VectorizedArray<float> &v)
+ operator*(const double u, const VectorizedArray<float> &v)
{
VectorizedArray<float> tmp;
tmp = float(u);
* @relatesalso VectorizedArray
*/
inline DEAL_II_ALWAYS_INLINE VectorizedArray<float>
- operator*(const VectorizedArray<float> &v, const double &u)
+ operator*(const VectorizedArray<float> &v, const double u)
{
return u * v;
}
* @relatesalso VectorizedArray
*/
inline DEAL_II_ALWAYS_INLINE VectorizedArray<float>
- operator/(const double &u, const VectorizedArray<float> &v)
+ operator/(const double u, const VectorizedArray<float> &v)
{
VectorizedArray<float> tmp;
tmp = float(u);
* @relatesalso VectorizedArray
*/
inline DEAL_II_ALWAYS_INLINE VectorizedArray<float>
- operator/(const VectorizedArray<float> &v, const double &u)
+ operator/(const VectorizedArray<float> &v, const double u)
{
VectorizedArray<float> tmp;
tmp = float(u);
return func_from(static_cast<const badouble &>(x), \
static_cast<const badouble &>(y)); \
} \
- inline adouble func_to(const double &x, const adouble &y) \
+ inline adouble func_to(const double x, const adouble &y) \
{ \
return func_from(x, static_cast<const badouble &>(y)); \
} \
- inline adouble func_to(const adouble &x, const double &y) \
+ inline adouble func_to(const adouble &x, const double y) \
{ \
return func_from(static_cast<const badouble &>(x), y); \
} \
{ \
return adtl::func_from(x, y); \
} \
- inline adtl::adouble func_to(const double &x, const adtl::adouble &y) \
+ inline adtl::adouble func_to(const double x, const adtl::adouble &y) \
{ \
return adtl::func_from(x, y); \
} \
- inline adtl::adouble func_to(const adtl::adouble &x, const double &y) \
+ inline adtl::adouble func_to(const adtl::adouble &x, const double y) \
{ \
return adtl::func_from(x, y); \
}
*/
std::vector<std::pair<unsigned int, double>>
get_points_within_ball(const Point<dim> &target,
- const double & radius,
+ const double radius,
const bool sorted = false) const;
/**
{
template <typename Number>
void
- set_possibly_complex_number(const double &r, const double &, Number &n)
+ set_possibly_complex_number(const double r, const double, Number &n)
{
n = r;
}
template <typename Type>
void
- set_possibly_complex_number(const double & r,
- const double & i,
+ set_possibly_complex_number(const double r,
+ const double i,
std::complex<Type> &n)
{
n = std::complex<Type>(r, i);
*/
template <int spacedim>
Point<spacedim>
- point(const gp_Pnt &p, const double &tolerance = 1e-10);
+ point(const gp_Pnt &p, const double tolerance = 1e-10);
/**
*/
AdditionalData(
// Initial parameters
- const double &initial_time = 0.0,
- const double &final_time = 1.0,
- const double &initial_step_size = 1e-2,
- const double &output_period = 1e-1,
+ const double initial_time = 0.0,
+ const double final_time = 1.0,
+ const double initial_step_size = 1e-2,
+ const double output_period = 1e-1,
// Running parameters
- const double & minimum_step_size = 1e-6,
+ const double minimum_step_size = 1e-6,
const unsigned int maximum_order = 5,
const unsigned int maximum_non_linear_iterations = 10,
const bool implicit_function_is_linear = false,
const bool implicit_function_is_time_independent = false,
// Error parameters
- const double &absolute_tolerance = 1e-6,
- const double &relative_tolerance = 1e-5)
+ const double absolute_tolerance = 1e-6,
+ const double relative_tolerance = 1e-5)
: initial_time(initial_time)
, final_time(final_time)
, initial_step_size(initial_step_size)
* @param[in,out] y The new initial solution
*/
void
- reset(const double &t, const double &h, const VectorType &y);
+ reset(const double t, const double h, const VectorType &y);
/**
* A function object that users need to supply and that is intended to
* iterations
*/
AdditionalData( // Initial parameters
- const double &initial_time = 0.0,
- const double &final_time = 1.0,
- const double &initial_step_size = 1e-2,
- const double &output_period = 1e-1,
+ const double initial_time = 0.0,
+ const double final_time = 1.0,
+ const double initial_step_size = 1e-2,
+ const double output_period = 1e-1,
// Running parameters
- const double & minimum_step_size = 1e-6,
+ const double minimum_step_size = 1e-6,
const unsigned int maximum_order = 5,
const unsigned int maximum_non_linear_iterations = 10,
// Error parameters
- const double &absolute_tolerance = 1e-6,
- const double &relative_tolerance = 1e-5,
- const bool ignore_algebraic_terms_for_errors = true,
+ const double absolute_tolerance = 1e-6,
+ const double relative_tolerance = 1e-5,
+ const bool ignore_algebraic_terms_for_errors = true,
// Initial conditions parameters
const InitialConditionCorrection &ic_type = use_y_diff,
const InitialConditionCorrection &reset_type = use_y_diff,
* @param[in,out] yp The new (tentative) initial solution_dot
*/
void
- reset(const double &t, const double &h, VectorType &y, VectorType &yp);
+ reset(const double t, const double h, VectorType &y, VectorType &yp);
/**
* Reinit vector to have the right size, MPI communicator, etc.
// Global parameters
const SolutionStrategy &strategy = linesearch,
const unsigned int maximum_non_linear_iterations = 200,
- const double & function_tolerance = 0.0,
- const double & step_tolerance = 0.0,
+ const double function_tolerance = 0.0,
+ const double step_tolerance = 0.0,
const bool no_init_setup = false,
const unsigned int maximum_setup_calls = 0,
- const double & maximum_newton_step = 0.0,
- const double & dq_relative_error = 0.0,
+ const double maximum_newton_step = 0.0,
+ const double dq_relative_error = 0.0,
const unsigned int maximum_beta_failures = 0,
const unsigned int anderson_subspace_size = 0)
: strategy(strategy)
// structures via a mutex.
Threads::Mutex::ScopedLock lock(acc_mutex);
- const double &x = p[0];
+ const double x = p[0];
Assert(x >= interpolation_points.front() &&
x <= interpolation_points.back(),
ExcCSplineRange(x,
// structures via a mutex.
Threads::Mutex::ScopedLock lock(acc_mutex);
- const double &x = p[0];
+ const double x = p[0];
Assert(x >= interpolation_points.front() &&
x <= interpolation_points.back(),
ExcCSplineRange(x,
// structures via a mutex.
Threads::Mutex::ScopedLock lock(acc_mutex);
- const double &x = p[0];
+ const double x = p[0];
Assert(x >= interpolation_points.front() &&
x <= interpolation_points.back(),
ExcCSplineRange(x,
*/
template <int dim>
void
- set_unit_vectors(const double & cos_theta,
- const double & sin_theta,
- const double & cos_phi,
- const double & sin_phi,
+ set_unit_vectors(const double cos_theta,
+ const double sin_theta,
+ const double cos_phi,
+ const double sin_phi,
Tensor<1, dim> &unit_r,
Tensor<1, dim> &unit_theta,
Tensor<1, dim> &unit_phi)
*/
template <int dim>
void add_outer_product(SymmetricTensor<2, dim> &out,
- const double & val,
+ const double val,
const Tensor<1, dim> & in1,
const Tensor<1, dim> & in2)
{
*/
template <int dim>
void add_outer_product(SymmetricTensor<2, dim> &out,
- const double & val,
+ const double val,
const Tensor<1, dim> & in)
{
if (val != 0.)
void
-ParameterHandler::set(const std::string &entry_string, const double &new_value)
+ParameterHandler::set(const std::string &entry_string, const double new_value)
{
std::ostringstream s;
s << std::setprecision(16);
compute_bounding_box(mesh, predicate);
// DOUBLE_EPSILON to compare really close double values
- const double &DOUBLE_EPSILON =
- 100. * std::numeric_limits<double>::epsilon();
+ const double DOUBLE_EPSILON = 100. * std::numeric_limits<double>::epsilon();
// Add layer_thickness to the bounding box
for (unsigned int d = 0; d < spacedim; ++d)
const Point<spacedim> &cell_enclosing_ball_center =
cell_enclosing_ball.first;
- const double &cell_enclosing_ball_radius = cell_enclosing_ball.second;
+ const double cell_enclosing_ball_radius = cell_enclosing_ball.second;
bool cell_inside = true; // reset for each cell
{
public:
TrilinosReductionControl(const int max_steps,
- const double & tolerance,
- const double & reduction,
+ const double tolerance,
+ const double reduction,
const Epetra_LinearProblem &linear_problem);
virtual ~TrilinosReductionControl() override = default;
TrilinosReductionControl::TrilinosReductionControl(
const int max_steps,
- const double & tolerance,
- const double & reduction,
+ const double tolerance,
+ const double reduction,
const Epetra_LinearProblem &linear_problem)
: initial_residual(std::numeric_limits<double>::max())
, current_residual(std::numeric_limits<double>::max())
template <int dim>
std::vector<std::pair<unsigned int, double>>
KDTree<dim>::get_points_within_ball(const Point<dim> ¢er,
- const double & radius,
+ const double radius,
bool sorted) const
{
Assert(adaptor, ExcNotInitialized());
template <int spacedim>
Point<spacedim>
- point(const gp_Pnt &p, const double &tolerance)
+ point(const gp_Pnt &p, const double tolerance)
{
(void)tolerance;
switch (spacedim)
const double tolerance);
template Point<deal_II_dimension> point(const gp_Pnt &p,
- const double &tolerance);
+ const double tolerance);
template gp_Pnt point(const Point<deal_II_dimension> &p);
template <typename VectorType>
void
- ARKode<VectorType>::reset(const double & current_time,
- const double & current_time_step,
+ ARKode<VectorType>::reset(const double current_time,
+ const double current_time_step,
const VectorType &solution)
{
unsigned int system_size;
template <typename VectorType>
void
- IDA<VectorType>::reset(const double ¤t_time,
- const double ¤t_time_step,
- VectorType & solution,
- VectorType & solution_dot)
+ IDA<VectorType>::reset(const double current_time,
+ const double current_time_step,
+ VectorType & solution,
+ VectorType & solution_dot)
{
unsigned int system_size;
bool first_step = (current_time == data.initial_time);