copy edit

Core/Export/PyFmt2.cpp

@@ -135,7 +135,8 @@ std::string printParameterDistribution(const ParameterDistribution& par_distr,
 
 std::string printRangedDistribution(const RangedDistribution& distr) {
     std::ostringstream result;
-    result << pyfmt::indent() << "distribution = " << distr.name();
+    result << pyfmt::indent() << "distribution = ba.";
+    result << distr.name();
     result << "(" << distr.nSamples() << ", " << pyfmt::printDouble(distr.sigmaFactor());
     if (!distr.limits().isLimitless())
         result << pyfmt::printRealLimitsArg(distr.limits());

Param/Distrib/RangedDistributions.cpp

@@ -18,11 +18,19 @@
 #include <limits>
 
 namespace {
-template <class T> std::unique_ptr<T> makeCopy(const T& item);
+
+template <class T> std::unique_ptr<T> makeCopy(const T& item) {
+    return std::make_unique<T>(item.nSamples(), item.sigmaFactor(), item.limits());
+}
 
 const double gate_stddev_factor = 2.0 * std::sqrt(3.0);
+
 } // namespace
 
+//  ************************************************************************************************
+//  interface RangedDistribution
+//  ************************************************************************************************
+
 RangedDistribution::RangedDistribution()
     : m_n_samples(5), m_sigma_factor(2.0), m_limits(RealLimits::limitless()) {
     checkInitialization();
@@ -97,6 +105,10 @@ void RangedDistribution::checkInitialization() {
                                  "shall not exceed the upper one.");
 }
 
+//  ************************************************************************************************
+//  class RangedDistributionGate
+//  ************************************************************************************************
+
 RangedDistributionGate::RangedDistributionGate() : RangedDistribution() {}
 
 RangedDistributionGate::RangedDistributionGate(size_t n_samples, double sigma_factor,
@@ -112,7 +124,7 @@ RangedDistributionGate* RangedDistributionGate::clone() const {
 }
 
 std::string RangedDistributionGate::name() const {
-    return "ba.RangedDistributionGate";
+    return "RangedDistributionGate";
 }
 
 std::unique_ptr<IDistribution1D> RangedDistributionGate::distribution_impl(double mean,
@@ -122,6 +134,10 @@ std::unique_ptr<IDistribution1D> RangedDistributionGate::distribution_impl(doubl
     return std::make_unique<DistributionGate>(x_min, x_max);
 }
 
+//  ************************************************************************************************
+//  class RangedDistributionLorentz
+//  ************************************************************************************************
+
 RangedDistributionLorentz::RangedDistributionLorentz() : RangedDistribution() {}
 
 RangedDistributionLorentz::RangedDistributionLorentz(size_t n_samples, double hwhm_factor,
@@ -137,7 +153,7 @@ RangedDistributionLorentz* RangedDistributionLorentz::clone() const {
 }
 
 std::string RangedDistributionLorentz::name() const {
-    return "ba.RangedDistributionLorentz";
+    return "RangedDistributionLorentz";
 }
 
 std::unique_ptr<IDistribution1D> RangedDistributionLorentz::distribution_impl(double median,
@@ -145,6 +161,10 @@ std::unique_ptr<IDistribution1D> RangedDistributionLorentz::distribution_impl(do
     return std::make_unique<DistributionLorentz>(median, hwhm);
 }
 
+//  ************************************************************************************************
+//  class RangedDistributionGaussian
+//  ************************************************************************************************
+
 RangedDistributionGaussian::RangedDistributionGaussian() : RangedDistribution() {}
 
 RangedDistributionGaussian::RangedDistributionGaussian(size_t n_samples, double sigma_factor,
@@ -160,7 +180,7 @@ RangedDistributionGaussian* RangedDistributionGaussian::clone() const {
 }
 
 std::string RangedDistributionGaussian::name() const {
-    return "ba.RangedDistributionGaussian";
+    return "RangedDistributionGaussian";
 }
 
 std::unique_ptr<IDistribution1D>
@@ -168,6 +188,10 @@ RangedDistributionGaussian::distribution_impl(double mean, double stddev) const
     return std::make_unique<DistributionGaussian>(mean, stddev);
 }
 
+//  ************************************************************************************************
+//  class RangedDistributionLogNormal
+//  ************************************************************************************************
+
 RangedDistributionLogNormal::RangedDistributionLogNormal() : RangedDistribution() {}
 
 RangedDistributionLogNormal::RangedDistributionLogNormal(size_t n_samples, double sigma_factor,
@@ -183,7 +207,7 @@ RangedDistributionLogNormal* RangedDistributionLogNormal::clone() const {
 }
 
 std::string RangedDistributionLogNormal::name() const {
-    return "ba.RangedDistributionLogNormal";
+    return "RangedDistributionLogNormal";
 }
 
 std::unique_ptr<IDistribution1D>
@@ -198,6 +222,10 @@ RangedDistributionLogNormal::distribution_impl(double mean, double stddev) const
     return std::make_unique<DistributionLogNormal>(median, scale);
 }
 
+//  ************************************************************************************************
+//  class RangedDistributionCosine
+//  ************************************************************************************************
+
 RangedDistributionCosine::RangedDistributionCosine() : RangedDistribution() {}
 
 RangedDistributionCosine::RangedDistributionCosine(size_t n_samples, double sigma_factor,
@@ -213,16 +241,10 @@ RangedDistributionCosine* RangedDistributionCosine::clone() const {
 }
 
 std::string RangedDistributionCosine::name() const {
-    return "ba.RangedDistributionCosine";
+    return "RangedDistributionCosine";
 }
 
 std::unique_ptr<IDistribution1D> RangedDistributionCosine::distribution_impl(double mean,
                                                                              double stddev) const {
     return std::make_unique<DistributionCosine>(mean, stddev);
 }
-
-namespace {
-template <class T> std::unique_ptr<T> makeCopy(const T& item) {
-    return std::make_unique<T>(item.nSamples(), item.sigmaFactor(), item.limits());
-}
-} // namespace

Tests/Functional/Python/Std/Check.cpp

@@ -50,7 +50,7 @@ std::unique_ptr<OutputData<double>> domainData(const std::string& test_name,
                                     + std::string("set NOPLOT=TRUE") + " & \""
                                     + BABuild::pythonExecutable() + "\" -B " + py_command;
 #endif
-    std::cout << "- system call: " << sys_command << std::endl; // flushing is important here
+    std::cout << "- system call: " << sys_command << std::endl;
     int ret = std::system(sys_command.c_str());
     if (ret != 0) {
         std::stringstream msg;