use in-class default construction

following C.45 from the GSL

src/fixed_point_iterator.hpp

@@ -202,7 +202,7 @@ class Fixed_point_iterator : public EWSB_solver {
    typedef Eigen::Matrix<double,dimension,1> Vector_t;
    typedef std::function<Vector_t(const Vector_t&)> Function_t;
 
-   Fixed_point_iterator();
+   Fixed_point_iterator() = default;
    Fixed_point_iterator(const Function_t&, std::size_t, const Convergence_tester&);
    virtual ~Fixed_point_iterator() {}
 
@@ -216,30 +216,17 @@ class Fixed_point_iterator : public EWSB_solver {
    virtual Eigen::VectorXd get_solution() const override;
 
 private:
-   std::size_t max_iterations;       ///< maximum number of iterations
-   GSL_vector xn;                    ///< current iteration point
-   GSL_vector fixed_point;           ///< vector of fixed point estimate
-   Function_t function;              ///< function defining fixed point
-   Convergence_tester convergence_tester; ///< convergence tester
+   std::size_t max_iterations{100};         ///< maximum number of iterations
+   GSL_vector xn{dimension};                ///< current iteration point
+   GSL_vector fixed_point{dimension};       ///< vector of fixed point estimate
+   Function_t function{nullptr};            ///< function defining fixed point
+   Convergence_tester convergence_tester{}; ///< convergence tester
 
    int fixed_point_iterator_iterate();
    void print_state(std::size_t) const;
    static int gsl_function(const gsl_vector*, void*, gsl_vector*);
 };
 
-/**
- * Default constructor
- */
-template <std::size_t dimension, class Convergence_tester>
-Fixed_point_iterator<dimension,Convergence_tester>::Fixed_point_iterator()
-   : max_iterations(100)
-   , xn(dimension)
-   , fixed_point(dimension)
-   , function(nullptr)
-   , convergence_tester(Convergence_tester())
-{
-}
-
 /**
  * Constructor
  *
@@ -254,8 +241,6 @@ Fixed_point_iterator<dimension,Convergence_tester>::Fixed_point_iterator(
    const Convergence_tester& convergence_tester_
 )
    : max_iterations(max_iterations_)
-   , xn(dimension)
-   , fixed_point(dimension)
    , function(function_)
    , convergence_tester(convergence_tester_)
 {

src/minimizer.hpp

@@ -61,7 +61,7 @@ class Minimizer : public EWSB_solver {
    typedef std::function<double(const Vector_t&)> Function_t;
    enum Solver_type { GSLSimplex, GSLSimplex2, GSLSimplex2Rand };
 
-   Minimizer();
+   Minimizer() = default;
    Minimizer(const Function_t&, std::size_t, double, Solver_type solver_type_ = GSLSimplex2);
    virtual ~Minimizer() {}
 
@@ -78,32 +78,18 @@ class Minimizer : public EWSB_solver {
    virtual Eigen::VectorXd get_solution() const override;
 
 private:
-   std::size_t max_iterations; ///< maximum number of iterations
-   double precision;           ///< precision goal
-   double minimum_value;       ///< minimum function value found
-   GSL_vector minimum_point;   ///< GSL vector of minimum point
-   Function_t function;        ///< function to minimize
-   Solver_type solver_type;    ///< minimizer type
+   std::size_t max_iterations{100};     ///< maximum number of iterations
+   double precision{1.e-2};             ///< precision goal
+   double minimum_value{0.};            ///< minimum function value found
+   GSL_vector minimum_point{dimension}; ///< GSL vector of minimum point
+   Function_t function{nullptr};        ///< function to minimize
+   Solver_type solver_type{GSLSimplex2};///< solver type
 
    void print_state(gsl_multimin_fminimizer*, std::size_t) const;
    static double gsl_function(const gsl_vector*, void*);
    const gsl_multimin_fminimizer_type* solver_type_to_gsl_pointer() const;
 };
 
-/**
- * Default constructor
- */
-template <std::size_t dimension>
-Minimizer<dimension>::Minimizer()
-   : max_iterations(100)
-   , precision(1.0e-2)
-   , minimum_value(0.0)
-   , minimum_point(dimension)
-   , function(nullptr)
-   , solver_type(GSLSimplex2)
-{
-}
-
 /**
  * Constructor
  *
@@ -121,8 +107,6 @@ Minimizer<dimension>::Minimizer(
 )
    : max_iterations(max_iterations_)
    , precision(precision_)
-   , minimum_value(0.0)
-   , minimum_point(dimension)
    , function(function_)
    , solver_type(solver_type_)
 {

src/root_finder.hpp

@@ -66,7 +66,7 @@ class Root_finder : public EWSB_solver {
    typedef std::function<Vector_t(const Vector_t&)> Function_t;
    enum Solver_type { GSLHybrid, GSLHybridS, GSLBroyden, GSLNewton };
 
-   Root_finder();
+   Root_finder() = default;
    Root_finder(const Function_t&, std::size_t, double, Solver_type solver_type_ = GSLHybrid);
    virtual ~Root_finder() {}
 
@@ -82,31 +82,18 @@ class Root_finder : public EWSB_solver {
    virtual Eigen::VectorXd get_solution() const override;
 
 private:
-   std::size_t max_iterations; ///< maximum number of iterations
-   double precision;           ///< precision goal
-   GSL_vector root;            ///< GSL vector of root
-   Function_t function;        ///< function to minimize
-   Solver_type solver_type;    ///< solver type
+   std::size_t max_iterations{100};    ///< maximum number of iterations
+   double precision{1.e-2};            ///< precision goal
+   GSL_vector root{dimension};         ///< GSL vector of root
+   Function_t function{nullptr};       ///< function to minimize
+   Solver_type solver_type{GSLHybrid}; ///< solver type
 
    void print_state(const gsl_multiroot_fsolver*, std::size_t) const;
    std::string solver_type_name() const;
    const gsl_multiroot_fsolver_type* solver_type_to_gsl_pointer() const;
    static int gsl_function(const gsl_vector*, void*, gsl_vector*);
 };
 
-/**
- * Default constructor
- */
-template <std::size_t dimension>
-Root_finder<dimension>::Root_finder()
-   : max_iterations(100)
-   , precision(1.0e-2)
-   , root(dimension)
-   , function(nullptr)
-   , solver_type(GSLHybrid)
-{
-}
-
 /**
  * Constructor
  *
@@ -124,7 +111,6 @@ Root_finder<dimension>::Root_finder(
 )
    : max_iterations(max_iterations_)
    , precision(precision_)
-   , root(dimension)
    , function(function_)
    , solver_type(solver_type_)
 {