From b6791085b34c448cbf596d872d9d7406415c051f Mon Sep 17 00:00:00 2001
From: Joachim Wuttke <j.wuttke@fz-juelich.de>
Date: Tue, 30 Aug 2022 12:41:10 +0200
Subject: [PATCH] Box: validate also precomputes; called by c'tor
---
Param/Node/INode.h | 2 +
Sample/HardParticle/Box.cpp | 31 +-
Sample/HardParticle/Box.h | 2 +
Sample/HardParticle/IFormFactorPrism.cpp | 2 +-
Sample/HardParticle/IFormFactorPrism.h | 6 +-
Sample/Multilayer/MultiLayer.cpp | 1 -
Tests/Unit/Sample/FormFactorBasicTest.cpp | 4 +-
auto/Wrap/doxygenParam.i | 360 +++++++++++-----------
auto/Wrap/doxygenSample.i | 3 +
auto/Wrap/libBornAgainParam.py | 226 +++++++-------
auto/Wrap/libBornAgainParam_wrap.cpp | 240 +++++++--------
auto/Wrap/libBornAgainSample.py | 8 +
auto/Wrap/libBornAgainSample_wrap.cpp | 28 ++
13 files changed, 488 insertions(+), 425 deletions(-)
diff --git a/Param/Node/INode.h b/Param/Node/INode.h
index 28610ff8210..a5e23a9f15a 100644
--- a/Param/Node/INode.h
+++ b/Param/Node/INode.h
@@ -61,6 +61,8 @@ public:
protected:
std::vector<double> m_P;
+
+ mutable bool m_validated{false};
};
// ************************************************************************************************
diff --git a/Sample/HardParticle/Box.cpp b/Sample/HardParticle/Box.cpp
index a10ffe6b406..b2efb5e1366 100644
--- a/Sample/HardParticle/Box.cpp
+++ b/Sample/HardParticle/Box.cpp
@@ -13,6 +13,8 @@
// ************************************************************************************************
#include "Sample/HardParticle/Box.h"
+#include "Base/Util/Assert.h"
+#include "Base/Util/StringUtils.h"
#include "Base/Math/Functions.h"
Box::Box(const std::vector<double> P)
@@ -21,11 +23,7 @@ Box::Box(const std::vector<double> P)
, m_width(m_P[1])
, m_height(m_P[2])
{
- checkNodeArgs();
- double a = m_length / 2;
- double b = m_width / 2;
- std::vector<R3> V{{a, b, 0.}, {-a, b, 0.}, {-a, -b, 0.}, {a, -b, 0}};
- setPrism(true, V);
+ validate();
}
Box::Box(double length, double width, double height)
@@ -35,7 +33,30 @@ Box::Box(double length, double width, double height)
complex_t Box::formfactor_at_bottom(C3 q) const
{
+ ASSERT(m_validated);
complex_t qzHdiv2 = m_height / 2 * q.z();
return m_length * m_width * m_height * Math::sinc(m_length / 2 * q.x())
* Math::sinc(m_width / 2 * q.y()) * Math::sinc(qzHdiv2) * exp_I(qzHdiv2);
}
+
+std::string Box::validate() const
+{
+ std::vector<std::string> errs;
+ if (m_length<=0)
+ errs.push_back("nonpositive length="+std::to_string(m_length));
+ if (m_width<=0)
+ errs.push_back("nonpositive width="+std::to_string(m_width));
+ if (m_height<=0)
+ errs.push_back("nonpositive height="+std::to_string(m_height));
+ if (!errs.empty())
+ return "{ Box: [ " + BaseUtils::String::join(errs, ", ") + " ] }";
+
+ double a = m_length / 2;
+ double b = m_width / 2;
+ std::vector<R3> V{{a, b, 0.}, {-a, b, 0.}, {-a, -b, 0.}, {a, -b, 0}};
+ setPrism(true, V);
+
+ m_validated = true;
+
+ return "";
+}
diff --git a/Sample/HardParticle/Box.h b/Sample/HardParticle/Box.h
index 6ad48d7e9ac..ce750de89c3 100644
--- a/Sample/HardParticle/Box.h
+++ b/Sample/HardParticle/Box.h
@@ -44,6 +44,8 @@ public:
double radialExtension() const override { return m_length / 2.0; }
complex_t formfactor_at_bottom(C3 q) const override;
+ std::string validate() const final;
+
private:
const double& m_length;
const double& m_width;
diff --git a/Sample/HardParticle/IFormFactorPrism.cpp b/Sample/HardParticle/IFormFactorPrism.cpp
index 0a430ab62e6..b5ac9f81b3b 100644
--- a/Sample/HardParticle/IFormFactorPrism.cpp
+++ b/Sample/HardParticle/IFormFactorPrism.cpp
@@ -23,7 +23,7 @@ IFormFactorPrism::IFormFactorPrism(const std::vector<double>& PValues)
IFormFactorPrism::~IFormFactorPrism() = default;
-void IFormFactorPrism::setPrism(bool symmetry_Ci, const std::vector<R3>& vertices)
+void IFormFactorPrism::setPrism(bool symmetry_Ci, const std::vector<R3>& vertices) const
{
pimpl = std::make_unique<ff::Prism>(symmetry_Ci, height(), vertices);
diff --git a/Sample/HardParticle/IFormFactorPrism.h b/Sample/HardParticle/IFormFactorPrism.h
index 8e22f60d3a4..f53dd2aad6d 100644
--- a/Sample/HardParticle/IFormFactorPrism.h
+++ b/Sample/HardParticle/IFormFactorPrism.h
@@ -42,15 +42,15 @@ public:
virtual double height() const = 0;
protected:
- void setPrism(bool symmetry_Ci, const std::vector<R3>& vertices);
+ void setPrism(bool symmetry_Ci, const std::vector<R3>& vertices) const;
// Each child must have a parameter m_height. We would like to move it here,
// but this seems incompatible with the current initialization of m_P and
// with the order of child constructor arguments, especially Box(l, w, h).
private:
- std::unique_ptr<ff::Prism> pimpl;
- std::vector<R3> m_vertices; //! for topZ, bottomZ computation only
+ mutable std::unique_ptr<ff::Prism> pimpl;
+ mutable std::vector<R3> m_vertices; //! for topZ, bottomZ computation only
};
#endif // BORNAGAIN_SAMPLE_HARDPARTICLE_IFORMFACTORPRISM_H
diff --git a/Sample/Multilayer/MultiLayer.cpp b/Sample/Multilayer/MultiLayer.cpp
index c9995d51b28..adb897dc1ee 100644
--- a/Sample/Multilayer/MultiLayer.cpp
+++ b/Sample/Multilayer/MultiLayer.cpp
@@ -13,7 +13,6 @@
// ************************************************************************************************
#include "Sample/Multilayer/MultiLayer.h"
-
#include "Base/Util/Assert.h"
#include "Base/Util/StringUtils.h"
#include "Fit/Param/RealLimits.h"
diff --git a/Tests/Unit/Sample/FormFactorBasicTest.cpp b/Tests/Unit/Sample/FormFactorBasicTest.cpp
index b49e313903e..a2332e5f9d4 100644
--- a/Tests/Unit/Sample/FormFactorBasicTest.cpp
+++ b/Tests/Unit/Sample/FormFactorBasicTest.cpp
@@ -105,8 +105,8 @@ TEST_F(FormFactorBasicTest, Bar)
TEST_F(FormFactorBasicTest, Box)
{
- EXPECT_THROW(Box(-6, 5, -7), std::runtime_error);
- // TODO EXPECT_THROW(Box(6, 0, 7), std::runtime_error);
+ EXPECT_NE(Box(-6, 5, -7).validate(), "");
+ EXPECT_NE(Box(6, 0, 7).validate(), "");
double length = 6.;
double height = 5.;
diff --git a/auto/Wrap/doxygenParam.i b/auto/Wrap/doxygenParam.i
index 1c2e6f13a5a..4e41841e5a2 100644
--- a/auto/Wrap/doxygenParam.i
+++ b/auto/Wrap/doxygenParam.i
@@ -10,52 +10,52 @@ C++ includes: Distributions.h
";
%feature("docstring") DistributionCosine::DistributionCosine "DistributionCosine::DistributionCosine(std::vector< double > P)
-";
+DistributionCosine::DistributionCosine";
%feature("docstring") DistributionCosine::DistributionCosine "DistributionCosine::DistributionCosine(double mean, double sigma)
-";
+DistributionCosine::DistributionCosine";
%feature("docstring") DistributionCosine::DistributionCosine "DistributionCosine::DistributionCosine()
-";
+DistributionCosine::DistributionCosine";
-%feature("docstring") DistributionCosine::clone "DistributionCosine* DistributionCosine::clone() const override
-";
+%feature("docstring") DistributionCosine::clone "DistributionCosine * DistributionCosine::clone() const override
+DistributionCosine::clone";
%feature("docstring") DistributionCosine::className "std::string DistributionCosine::className() const final
-
+DistributionCosine::className
Returns the class name, to be hard-coded in each leaf class that inherits from INode.
";
-%feature("docstring") DistributionCosine::parDefs "std::vector<ParaMeta> DistributionCosine::parDefs() const final
-
+%feature("docstring") DistributionCosine::parDefs "std::vector< ParaMeta > DistributionCosine::parDefs() const final
+DistributionCosine::parDefs
Returns the parameter definitions, to be hard-coded in each leaf class.
";
%feature("docstring") DistributionCosine::probabilityDensity "double DistributionCosine::probabilityDensity(double x) const override
-
+DistributionCosine::probabilityDensity
Returns the distribution-specific probability density for value x.
";
%feature("docstring") DistributionCosine::mean "double DistributionCosine::mean() const override
-
+DistributionCosine::mean
Returns the distribution-specific mean.
";
%feature("docstring") DistributionCosine::sigma "double DistributionCosine::sigma() const
-";
+DistributionCosine::sigma";
%feature("docstring") DistributionCosine::equidistantPoints "std::vector< double > DistributionCosine::equidistantPoints(size_t nbr_samples, double sigma_factor, const RealLimits &limits={}) const override
-
+DistributionCosine::equidistantPoints
generate list of sample values
";
%feature("docstring") DistributionCosine::isDelta "bool DistributionCosine::isDelta() const override
-
+DistributionCosine::isDelta
Returns true if the distribution is in the limit case of a Dirac delta distribution.
";
%feature("docstring") DistributionCosine::pythonConstructor "std::string DistributionCosine::pythonConstructor(const std::string &units) const override
-
+DistributionCosine::pythonConstructor
Prints distribution with constructor parameters in given units. ba.DistributionGaussian(2.0*deg, 0.02*deg)
";
@@ -69,55 +69,55 @@ C++ includes: Distributions.h
";
%feature("docstring") DistributionGate::DistributionGate "DistributionGate::DistributionGate(std::vector< double > P)
-";
+DistributionGate::DistributionGate";
%feature("docstring") DistributionGate::DistributionGate "DistributionGate::DistributionGate(double min, double max)
-";
+DistributionGate::DistributionGate";
%feature("docstring") DistributionGate::DistributionGate "DistributionGate::DistributionGate()
-";
+DistributionGate::DistributionGate";
-%feature("docstring") DistributionGate::clone "DistributionGate* DistributionGate::clone() const override
-";
+%feature("docstring") DistributionGate::clone "DistributionGate * DistributionGate::clone() const override
+DistributionGate::clone";
%feature("docstring") DistributionGate::className "std::string DistributionGate::className() const final
-
+DistributionGate::className
Returns the class name, to be hard-coded in each leaf class that inherits from INode.
";
-%feature("docstring") DistributionGate::parDefs "std::vector<ParaMeta> DistributionGate::parDefs() const final
-
+%feature("docstring") DistributionGate::parDefs "std::vector< ParaMeta > DistributionGate::parDefs() const final
+DistributionGate::parDefs
Returns the parameter definitions, to be hard-coded in each leaf class.
";
%feature("docstring") DistributionGate::probabilityDensity "double DistributionGate::probabilityDensity(double x) const override
-
+DistributionGate::probabilityDensity
Returns the distribution-specific probability density for value x.
";
%feature("docstring") DistributionGate::mean "double DistributionGate::mean() const override
-
+DistributionGate::mean
Returns the distribution-specific mean.
";
%feature("docstring") DistributionGate::min "double DistributionGate::min() const
-";
+DistributionGate::min";
%feature("docstring") DistributionGate::max "double DistributionGate::max() const
-";
+DistributionGate::max";
%feature("docstring") DistributionGate::equidistantPoints "std::vector< double > DistributionGate::equidistantPoints(size_t nbr_samples, double sigma_factor, const RealLimits &limits={}) const override
-
+DistributionGate::equidistantPoints
Returns list of sample values.
";
%feature("docstring") DistributionGate::isDelta "bool DistributionGate::isDelta() const override
-
+DistributionGate::isDelta
Returns true if the distribution is in the limit case of a Dirac delta distribution.
";
%feature("docstring") DistributionGate::pythonConstructor "std::string DistributionGate::pythonConstructor(const std::string &units) const override
-
+DistributionGate::pythonConstructor
Prints distribution with constructor parameters in given units. ba.DistributionGaussian(2.0*deg, 0.02*deg)
";
@@ -131,52 +131,52 @@ C++ includes: Distributions.h
";
%feature("docstring") DistributionGaussian::DistributionGaussian "DistributionGaussian::DistributionGaussian(std::vector< double > P)
-";
+DistributionGaussian::DistributionGaussian";
%feature("docstring") DistributionGaussian::DistributionGaussian "DistributionGaussian::DistributionGaussian(double mean, double std_dev)
-";
+DistributionGaussian::DistributionGaussian";
%feature("docstring") DistributionGaussian::DistributionGaussian "DistributionGaussian::DistributionGaussian()
-";
+DistributionGaussian::DistributionGaussian";
-%feature("docstring") DistributionGaussian::clone "DistributionGaussian* DistributionGaussian::clone() const override
-";
+%feature("docstring") DistributionGaussian::clone "DistributionGaussian * DistributionGaussian::clone() const override
+DistributionGaussian::clone";
%feature("docstring") DistributionGaussian::className "std::string DistributionGaussian::className() const final
-
+DistributionGaussian::className
Returns the class name, to be hard-coded in each leaf class that inherits from INode.
";
-%feature("docstring") DistributionGaussian::parDefs "std::vector<ParaMeta> DistributionGaussian::parDefs() const final
-
+%feature("docstring") DistributionGaussian::parDefs "std::vector< ParaMeta > DistributionGaussian::parDefs() const final
+DistributionGaussian::parDefs
Returns the parameter definitions, to be hard-coded in each leaf class.
";
%feature("docstring") DistributionGaussian::probabilityDensity "double DistributionGaussian::probabilityDensity(double x) const override
-
+DistributionGaussian::probabilityDensity
Returns the distribution-specific probability density for value x.
";
%feature("docstring") DistributionGaussian::mean "double DistributionGaussian::mean() const override
-
+DistributionGaussian::mean
Returns the distribution-specific mean.
";
%feature("docstring") DistributionGaussian::getStdDev "double DistributionGaussian::getStdDev() const
-";
+DistributionGaussian::getStdDev";
%feature("docstring") DistributionGaussian::equidistantPoints "std::vector< double > DistributionGaussian::equidistantPoints(size_t nbr_samples, double sigma_factor, const RealLimits &limits={}) const override
-
+DistributionGaussian::equidistantPoints
generate list of sample values
";
%feature("docstring") DistributionGaussian::isDelta "bool DistributionGaussian::isDelta() const override
-
+DistributionGaussian::isDelta
Returns true if the distribution is in the limit case of a Dirac delta distribution.
";
%feature("docstring") DistributionGaussian::pythonConstructor "std::string DistributionGaussian::pythonConstructor(const std::string &units) const override
-
+DistributionGaussian::pythonConstructor
Prints distribution with constructor parameters in given units. ba.DistributionGaussian(2.0*deg, 0.02*deg)
";
@@ -190,29 +190,29 @@ C++ includes: DistributionHandler.h
";
%feature("docstring") DistributionHandler::DistributionHandler "DistributionHandler::DistributionHandler()
-";
+DistributionHandler::DistributionHandler";
%feature("docstring") DistributionHandler::~DistributionHandler "DistributionHandler::~DistributionHandler()
-";
+DistributionHandler::~DistributionHandler";
%feature("docstring") DistributionHandler::addParameterDistribution "void DistributionHandler::addParameterDistribution(const ParameterDistribution &par_distr)
-";
+DistributionHandler::addParameterDistribution";
%feature("docstring") DistributionHandler::getTotalNumberOfSamples "size_t DistributionHandler::getTotalNumberOfSamples() const
-
+DistributionHandler::getTotalNumberOfSamples
get the total number of parameter value combinations (product of the individual sizes of each parameter distribution
";
%feature("docstring") DistributionHandler::setParameterValues "double DistributionHandler::setParameterValues(size_t index)
-
+DistributionHandler::setParameterValues
set the parameter values of the simulation object to a specific combination of values, determined by the index (which must be smaller than the total number of combinations) and returns the weight associated with this combination of parameter values. initParameterLinks() has to be called before this!
";
%feature("docstring") DistributionHandler::getDistributions "const std::vector< ParameterDistribution > & DistributionHandler::getDistributions() const
-";
+DistributionHandler::getDistributions";
%feature("docstring") DistributionHandler::defineCallbackForDistribution "void DistributionHandler::defineCallbackForDistribution(const ParameterDistribution *distribution, std::function< void(double)> fn)
-";
+DistributionHandler::defineCallbackForDistribution";
// File: classDistributionLogNormal.xml
@@ -224,52 +224,52 @@ C++ includes: Distributions.h
";
%feature("docstring") DistributionLogNormal::DistributionLogNormal "DistributionLogNormal::DistributionLogNormal(std::vector< double > P)
-";
+DistributionLogNormal::DistributionLogNormal";
%feature("docstring") DistributionLogNormal::DistributionLogNormal "DistributionLogNormal::DistributionLogNormal(double median, double scale_param)
-";
+DistributionLogNormal::DistributionLogNormal";
-%feature("docstring") DistributionLogNormal::clone "DistributionLogNormal* DistributionLogNormal::clone() const override
-";
+%feature("docstring") DistributionLogNormal::clone "DistributionLogNormal * DistributionLogNormal::clone() const override
+DistributionLogNormal::clone";
%feature("docstring") DistributionLogNormal::className "std::string DistributionLogNormal::className() const final
-
+DistributionLogNormal::className
Returns the class name, to be hard-coded in each leaf class that inherits from INode.
";
-%feature("docstring") DistributionLogNormal::parDefs "std::vector<ParaMeta> DistributionLogNormal::parDefs() const final
-
+%feature("docstring") DistributionLogNormal::parDefs "std::vector< ParaMeta > DistributionLogNormal::parDefs() const final
+DistributionLogNormal::parDefs
Returns the parameter definitions, to be hard-coded in each leaf class.
";
%feature("docstring") DistributionLogNormal::probabilityDensity "double DistributionLogNormal::probabilityDensity(double x) const override
-
+DistributionLogNormal::probabilityDensity
Returns the distribution-specific probability density for value x.
";
%feature("docstring") DistributionLogNormal::mean "double DistributionLogNormal::mean() const override
-
+DistributionLogNormal::mean
Returns the distribution-specific mean.
";
%feature("docstring") DistributionLogNormal::getMedian "double DistributionLogNormal::getMedian() const
-";
+DistributionLogNormal::getMedian";
%feature("docstring") DistributionLogNormal::getScalePar "double DistributionLogNormal::getScalePar() const
-";
+DistributionLogNormal::getScalePar";
%feature("docstring") DistributionLogNormal::equidistantPoints "std::vector< double > DistributionLogNormal::equidistantPoints(size_t nbr_samples, double sigma_factor, const RealLimits &limits={}) const override
-
+DistributionLogNormal::equidistantPoints
generate list of sample values
";
%feature("docstring") DistributionLogNormal::isDelta "bool DistributionLogNormal::isDelta() const override
-
+DistributionLogNormal::isDelta
Returns true if the distribution is in the limit case of a Dirac delta distribution.
";
%feature("docstring") DistributionLogNormal::pythonConstructor "std::string DistributionLogNormal::pythonConstructor(const std::string &units) const override
-
+DistributionLogNormal::pythonConstructor
Prints distribution with constructor parameters in given units. ba.DistributionGaussian(2.0*deg, 0.02*deg)
";
@@ -283,52 +283,52 @@ C++ includes: Distributions.h
";
%feature("docstring") DistributionLorentz::DistributionLorentz "DistributionLorentz::DistributionLorentz(std::vector< double > P)
-";
+DistributionLorentz::DistributionLorentz";
%feature("docstring") DistributionLorentz::DistributionLorentz "DistributionLorentz::DistributionLorentz(double mean, double hwhm)
-";
+DistributionLorentz::DistributionLorentz";
%feature("docstring") DistributionLorentz::DistributionLorentz "DistributionLorentz::DistributionLorentz()
-";
+DistributionLorentz::DistributionLorentz";
-%feature("docstring") DistributionLorentz::clone "DistributionLorentz* DistributionLorentz::clone() const override
-";
+%feature("docstring") DistributionLorentz::clone "DistributionLorentz * DistributionLorentz::clone() const override
+DistributionLorentz::clone";
%feature("docstring") DistributionLorentz::className "std::string DistributionLorentz::className() const final
-
+DistributionLorentz::className
Returns the class name, to be hard-coded in each leaf class that inherits from INode.
";
-%feature("docstring") DistributionLorentz::parDefs "std::vector<ParaMeta> DistributionLorentz::parDefs() const final
-
+%feature("docstring") DistributionLorentz::parDefs "std::vector< ParaMeta > DistributionLorentz::parDefs() const final
+DistributionLorentz::parDefs
Returns the parameter definitions, to be hard-coded in each leaf class.
";
%feature("docstring") DistributionLorentz::probabilityDensity "double DistributionLorentz::probabilityDensity(double x) const override
-
+DistributionLorentz::probabilityDensity
Returns the distribution-specific probability density for value x.
";
%feature("docstring") DistributionLorentz::mean "double DistributionLorentz::mean() const override
-
+DistributionLorentz::mean
Returns the distribution-specific mean.
";
%feature("docstring") DistributionLorentz::hwhm "double DistributionLorentz::hwhm() const
-";
+DistributionLorentz::hwhm";
%feature("docstring") DistributionLorentz::equidistantPoints "std::vector< double > DistributionLorentz::equidistantPoints(size_t nbr_samples, double sigma_factor, const RealLimits &limits={}) const override
-
+DistributionLorentz::equidistantPoints
generate list of sample values
";
%feature("docstring") DistributionLorentz::isDelta "bool DistributionLorentz::isDelta() const override
-
+DistributionLorentz::isDelta
Returns true if the distribution is in the limit case of a Dirac delta distribution.
";
%feature("docstring") DistributionLorentz::pythonConstructor "std::string DistributionLorentz::pythonConstructor(const std::string &units) const override
-
+DistributionLorentz::pythonConstructor
Prints distribution with constructor parameters in given units. ba.DistributionGaussian(2.0*deg, 0.02*deg)
";
@@ -342,58 +342,58 @@ C++ includes: Distributions.h
";
%feature("docstring") DistributionTrapezoid::DistributionTrapezoid "DistributionTrapezoid::DistributionTrapezoid(std::vector< double > P)
-";
+DistributionTrapezoid::DistributionTrapezoid";
%feature("docstring") DistributionTrapezoid::DistributionTrapezoid "DistributionTrapezoid::DistributionTrapezoid(double center, double left, double middle, double right)
-";
+DistributionTrapezoid::DistributionTrapezoid";
%feature("docstring") DistributionTrapezoid::DistributionTrapezoid "DistributionTrapezoid::DistributionTrapezoid()
-";
+DistributionTrapezoid::DistributionTrapezoid";
-%feature("docstring") DistributionTrapezoid::clone "DistributionTrapezoid* DistributionTrapezoid::clone() const override
-";
+%feature("docstring") DistributionTrapezoid::clone "DistributionTrapezoid * DistributionTrapezoid::clone() const override
+DistributionTrapezoid::clone";
%feature("docstring") DistributionTrapezoid::className "std::string DistributionTrapezoid::className() const final
-
+DistributionTrapezoid::className
Returns the class name, to be hard-coded in each leaf class that inherits from INode.
";
-%feature("docstring") DistributionTrapezoid::parDefs "std::vector<ParaMeta> DistributionTrapezoid::parDefs() const final
-
+%feature("docstring") DistributionTrapezoid::parDefs "std::vector< ParaMeta > DistributionTrapezoid::parDefs() const final
+DistributionTrapezoid::parDefs
Returns the parameter definitions, to be hard-coded in each leaf class.
";
%feature("docstring") DistributionTrapezoid::probabilityDensity "double DistributionTrapezoid::probabilityDensity(double x) const override
-
+DistributionTrapezoid::probabilityDensity
Returns the distribution-specific probability density for value x.
";
%feature("docstring") DistributionTrapezoid::mean "double DistributionTrapezoid::mean() const override
-
+DistributionTrapezoid::mean
Returns the distribution-specific mean.
";
%feature("docstring") DistributionTrapezoid::getLeftWidth "double DistributionTrapezoid::getLeftWidth() const
-";
+DistributionTrapezoid::getLeftWidth";
%feature("docstring") DistributionTrapezoid::getMiddleWidth "double DistributionTrapezoid::getMiddleWidth() const
-";
+DistributionTrapezoid::getMiddleWidth";
%feature("docstring") DistributionTrapezoid::getRightWidth "double DistributionTrapezoid::getRightWidth() const
-";
+DistributionTrapezoid::getRightWidth";
%feature("docstring") DistributionTrapezoid::equidistantPoints "std::vector< double > DistributionTrapezoid::equidistantPoints(size_t nbr_samples, double sigma_factor, const RealLimits &limits={}) const override
-
+DistributionTrapezoid::equidistantPoints
generate list of sample values
";
%feature("docstring") DistributionTrapezoid::isDelta "bool DistributionTrapezoid::isDelta() const override
-
+DistributionTrapezoid::isDelta
Returns true if the distribution is in the limit case of a Dirac delta distribution.
";
%feature("docstring") DistributionTrapezoid::pythonConstructor "std::string DistributionTrapezoid::pythonConstructor(const std::string &units) const override
-
+DistributionTrapezoid::pythonConstructor
Prints distribution with constructor parameters in given units. ba.DistributionGaussian(2.0*deg, 0.02*deg)
";
@@ -407,48 +407,48 @@ C++ includes: Distributions.h
";
%feature("docstring") IDistribution1D::IDistribution1D "IDistribution1D::IDistribution1D(const std::vector< double > &PValues)
-";
+IDistribution1D::IDistribution1D";
-%feature("docstring") IDistribution1D::clone "IDistribution1D* IDistribution1D::clone() const override=0
-";
+%feature("docstring") IDistribution1D::clone "IDistribution1D * IDistribution1D::clone() const override=0
+IDistribution1D::clone";
%feature("docstring") IDistribution1D::probabilityDensity "virtual double IDistribution1D::probabilityDensity(double x) const =0
-
+IDistribution1D::probabilityDensity
Returns the distribution-specific probability density for value x.
";
%feature("docstring") IDistribution1D::mean "virtual double IDistribution1D::mean() const =0
-
+IDistribution1D::mean
Returns the distribution-specific mean.
";
%feature("docstring") IDistribution1D::equidistantSamples "std::vector< ParameterSample > IDistribution1D::equidistantSamples(size_t nbr_samples, double sigma_factor=0., const RealLimits &limits={}) const
-
+IDistribution1D::equidistantSamples
Returns equidistant samples, using intrinsic parameters, weighted with probabilityDensity().
";
%feature("docstring") IDistribution1D::equidistantSamplesInRange "std::vector< ParameterSample > IDistribution1D::equidistantSamplesInRange(size_t nbr_samples, double xmin, double xmax) const
-
+IDistribution1D::equidistantSamplesInRange
Returns equidistant samples from xmin to xmax, weighted with probabilityDensity().
";
-%feature("docstring") IDistribution1D::equidistantPoints "virtual std::vector<double> IDistribution1D::equidistantPoints(size_t nbr_samples, double sigma_factor, const RealLimits &limits={}) const =0
-
+%feature("docstring") IDistribution1D::equidistantPoints "virtual std::vector< double > IDistribution1D::equidistantPoints(size_t nbr_samples, double sigma_factor, const RealLimits &limits={}) const =0
+IDistribution1D::equidistantPoints
Returns equidistant interpolation points, with range computed in distribution-specific way from mean and width parameter, taking into account limits and sigma_factor.
";
%feature("docstring") IDistribution1D::equidistantPointsInRange "std::vector< double > IDistribution1D::equidistantPointsInRange(size_t nbr_samples, double xmin, double xmax) const
-
+IDistribution1D::equidistantPointsInRange
Returns equidistant interpolation points from xmin to xmax.
";
%feature("docstring") IDistribution1D::isDelta "virtual bool IDistribution1D::isDelta() const =0
-
+IDistribution1D::isDelta
Returns true if the distribution is in the limit case of a Dirac delta distribution.
";
%feature("docstring") IDistribution1D::pythonConstructor "virtual std::string IDistribution1D::pythonConstructor(const std::string &units) const =0
-
+IDistribution1D::pythonConstructor
Prints distribution with constructor parameters in given units. ba.DistributionGaussian(2.0*deg, 0.02*deg)
";
@@ -462,36 +462,36 @@ C++ includes: INode.h
";
%feature("docstring") INode::INode "INode::INode()=default
-";
+INode::INode";
%feature("docstring") INode::INode "INode::INode(std::vector< double > PValues)
-";
+INode::INode";
%feature("docstring") INode::~INode "virtual INode::~INode()=default
-";
+INode::~INode";
%feature("docstring") INode::className "virtual std::string INode::className() const =0
-
+INode::className
Returns the class name, to be hard-coded in each leaf class that inherits from INode.
";
-%feature("docstring") INode::parDefs "virtual std::vector<ParaMeta> INode::parDefs() const
-
+%feature("docstring") INode::parDefs "virtual std::vector< ParaMeta > INode::parDefs() const
+INode::parDefs
Returns the parameter definitions, to be hard-coded in each leaf class.
";
%feature("docstring") INode::checkNodeArgs "void INode::checkNodeArgs() const
-
+INode::checkNodeArgs
Raises exception if a parameter value is invalid.
";
%feature("docstring") INode::nodeChildren "std::vector< const INode * > INode::nodeChildren() const
-
+INode::nodeChildren
Returns all children.
";
%feature("docstring") INode::nodeOffspring "std::vector< const INode * > INode::nodeOffspring() const
-
+INode::nodeOffspring
Returns all descendants.
";
@@ -505,55 +505,55 @@ C++ includes: RangedDistributions.h
";
%feature("docstring") IRangedDistribution::IRangedDistribution "IRangedDistribution::IRangedDistribution()
-";
+IRangedDistribution::IRangedDistribution";
%feature("docstring") IRangedDistribution::IRangedDistribution "IRangedDistribution::IRangedDistribution(size_t n_samples, double sigma_factor, const RealLimits &limits=RealLimits::limitless())
-";
+IRangedDistribution::IRangedDistribution";
%feature("docstring") IRangedDistribution::IRangedDistribution "IRangedDistribution::IRangedDistribution(size_t n_samples, double sigma_factor, double min, double max)
-
+IRangedDistribution::IRangedDistribution
Initializes Ranged distribution with given number of samples, sigma factor (range in standard deviations to take into account during sample generation) and limits (either RealLimits object or just min and max limits). By default n_samples = 5, sigma_factor = 2.0, while the limits are (-inf, +inf).
";
-%feature("docstring") IRangedDistribution::clone "IRangedDistribution* IRangedDistribution::clone() const override=0
-";
+%feature("docstring") IRangedDistribution::clone "IRangedDistribution * IRangedDistribution::clone() const override=0
+IRangedDistribution::clone";
%feature("docstring") IRangedDistribution::~IRangedDistribution "IRangedDistribution::~IRangedDistribution() override
-";
+IRangedDistribution::~IRangedDistribution";
%feature("docstring") IRangedDistribution::generateSamples "std::vector< ParameterSample > IRangedDistribution::generateSamples(double mean, double stddev) const
-";
+IRangedDistribution::generateSamples";
%feature("docstring") IRangedDistribution::generateSamples "std::vector< std::vector< ParameterSample > > IRangedDistribution::generateSamples(const std::vector< double > &mean, const std::vector< double > &stddev) const
-
+IRangedDistribution::generateSamples
Generates list of sampled values with their weights from given means and standard deviations.
";
%feature("docstring") IRangedDistribution::distribution "IDistribution1D * IRangedDistribution::distribution(double mean, double stddev) const
-
+IRangedDistribution::distribution
Public interface function to underlying IDistribution1D object.
";
%feature("docstring") IRangedDistribution::limits "RealLimits IRangedDistribution::limits() const
-
+IRangedDistribution::limits
Returns current limits of the distribution.
";
%feature("docstring") IRangedDistribution::sigmaFactor "double IRangedDistribution::sigmaFactor() const
-
+IRangedDistribution::sigmaFactor
Returns sigma factor to use during sampling.
";
%feature("docstring") IRangedDistribution::nSamples "size_t IRangedDistribution::nSamples() const
-
+IRangedDistribution::nSamples
Returns number of samples to generate.
";
%feature("docstring") IRangedDistribution::setLimits "void IRangedDistribution::setLimits(const RealLimits &limits)
-";
+IRangedDistribution::setLimits";
%feature("docstring") IRangedDistribution::name "virtual std::string IRangedDistribution::name() const =0
-
+IRangedDistribution::name
Returns distribution name for python-formatted text.
";
@@ -576,52 +576,52 @@ C++ includes: ParameterDistribution.h
";
%feature("docstring") ParameterDistribution::ParameterDistribution "ParameterDistribution::ParameterDistribution(WhichParameter whichParameter, const IDistribution1D &distribution, size_t nbr_samples, double sigma_factor=0.0, const RealLimits &limits=RealLimits())
-";
+ParameterDistribution::ParameterDistribution";
%feature("docstring") ParameterDistribution::ParameterDistribution "ParameterDistribution::ParameterDistribution(WhichParameter whichParameter, const IDistribution1D &distribution, size_t nbr_samples, double xmin, double xmax)
-";
+ParameterDistribution::ParameterDistribution";
%feature("docstring") ParameterDistribution::ParameterDistribution "ParameterDistribution::ParameterDistribution(const ParameterDistribution &other)
-";
+ParameterDistribution::ParameterDistribution";
%feature("docstring") ParameterDistribution::~ParameterDistribution "ParameterDistribution::~ParameterDistribution()
-";
+ParameterDistribution::~ParameterDistribution";
%feature("docstring") ParameterDistribution::whichParameter "ParameterDistribution::WhichParameter ParameterDistribution::whichParameter() const
-";
+ParameterDistribution::whichParameter";
%feature("docstring") ParameterDistribution::whichParameterAsPyEnum "std::string ParameterDistribution::whichParameterAsPyEnum() const
-";
+ParameterDistribution::whichParameterAsPyEnum";
%feature("docstring") ParameterDistribution::nDraws "size_t ParameterDistribution::nDraws() const
-
+ParameterDistribution::nDraws
get number of samples for this distribution
";
%feature("docstring") ParameterDistribution::sigmaFactor "double ParameterDistribution::sigmaFactor() const
-
+ParameterDistribution::sigmaFactor
get the sigma factor
";
%feature("docstring") ParameterDistribution::getDistribution "const IDistribution1D * ParameterDistribution::getDistribution() const
-";
+ParameterDistribution::getDistribution";
%feature("docstring") ParameterDistribution::getDistribution "IDistribution1D * ParameterDistribution::getDistribution()
-";
+ParameterDistribution::getDistribution";
%feature("docstring") ParameterDistribution::generateSamples "std::vector< ParameterSample > ParameterDistribution::generateSamples() const
-
+ParameterDistribution::generateSamples
generate list of sampled values with their weight
";
%feature("docstring") ParameterDistribution::getLimits "RealLimits ParameterDistribution::getLimits() const
-";
+ParameterDistribution::getLimits";
%feature("docstring") ParameterDistribution::getMinValue "double ParameterDistribution::getMinValue() const
-";
+ParameterDistribution::getMinValue";
%feature("docstring") ParameterDistribution::getMaxValue "double ParameterDistribution::getMaxValue() const
-";
+ParameterDistribution::getMaxValue";
// File: classParameterSample.xml
@@ -633,7 +633,7 @@ C++ includes: ParameterSample.h
";
%feature("docstring") ParameterSample::ParameterSample "ParameterSample::ParameterSample(double _value, double _weight=1)
-";
+ParameterSample::ParameterSample";
// File: classRangedDistributionCosine.xml
@@ -645,24 +645,24 @@ C++ includes: RangedDistributions.h
";
%feature("docstring") RangedDistributionCosine::RangedDistributionCosine "RangedDistributionCosine::RangedDistributionCosine()
-";
+RangedDistributionCosine::RangedDistributionCosine";
%feature("docstring") RangedDistributionCosine::RangedDistributionCosine "RangedDistributionCosine::RangedDistributionCosine(size_t n_samples, double sigma_factor, const RealLimits &limits=RealLimits::limitless())
-";
+RangedDistributionCosine::RangedDistributionCosine";
%feature("docstring") RangedDistributionCosine::RangedDistributionCosine "RangedDistributionCosine::RangedDistributionCosine(size_t n_samples, double sigma_factor, double min, double max)
-
+RangedDistributionCosine::RangedDistributionCosine
Initializes Ranged distribution with given number of samples, sigma factor (range in standard deviations to take into account during sample generation) and limits (either RealLimits object or just min and max limits). By default n_samples = 5, sigma_factor = 2.0, while the limits are (-inf, +inf).
";
%feature("docstring") RangedDistributionCosine::clone "RangedDistributionCosine * RangedDistributionCosine::clone() const override
-";
+RangedDistributionCosine::clone";
%feature("docstring") RangedDistributionCosine::~RangedDistributionCosine "RangedDistributionCosine::~RangedDistributionCosine() override=default
-";
+RangedDistributionCosine::~RangedDistributionCosine";
%feature("docstring") RangedDistributionCosine::name "std::string RangedDistributionCosine::name() const override
-
+RangedDistributionCosine::name
Returns distribution name for python-formatted text.
";
@@ -676,24 +676,24 @@ C++ includes: RangedDistributions.h
";
%feature("docstring") RangedDistributionGate::RangedDistributionGate "RangedDistributionGate::RangedDistributionGate()
-";
+RangedDistributionGate::RangedDistributionGate";
%feature("docstring") RangedDistributionGate::RangedDistributionGate "RangedDistributionGate::RangedDistributionGate(size_t n_samples, double sigma_factor, const RealLimits &limits=RealLimits::limitless())
-";
+RangedDistributionGate::RangedDistributionGate";
%feature("docstring") RangedDistributionGate::RangedDistributionGate "RangedDistributionGate::RangedDistributionGate(size_t n_samples, double sigma_factor, double min, double max)
-
+RangedDistributionGate::RangedDistributionGate
Initializes Ranged distribution with given number of samples, sigma factor (range in standard deviations to take into account during sample generation) and limits (either RealLimits object or just min and max limits). By default n_samples = 5, sigma_factor = 2.0, while the limits are (-inf, +inf).
";
%feature("docstring") RangedDistributionGate::clone "RangedDistributionGate * RangedDistributionGate::clone() const override
-";
+RangedDistributionGate::clone";
%feature("docstring") RangedDistributionGate::~RangedDistributionGate "RangedDistributionGate::~RangedDistributionGate() override=default
-";
+RangedDistributionGate::~RangedDistributionGate";
%feature("docstring") RangedDistributionGate::name "std::string RangedDistributionGate::name() const override
-
+RangedDistributionGate::name
Returns distribution name for python-formatted text.
";
@@ -707,24 +707,24 @@ C++ includes: RangedDistributions.h
";
%feature("docstring") RangedDistributionGaussian::RangedDistributionGaussian "RangedDistributionGaussian::RangedDistributionGaussian()
-";
+RangedDistributionGaussian::RangedDistributionGaussian";
%feature("docstring") RangedDistributionGaussian::RangedDistributionGaussian "RangedDistributionGaussian::RangedDistributionGaussian(size_t n_samples, double sigma_factor, const RealLimits &limits=RealLimits::limitless())
-";
+RangedDistributionGaussian::RangedDistributionGaussian";
%feature("docstring") RangedDistributionGaussian::RangedDistributionGaussian "RangedDistributionGaussian::RangedDistributionGaussian(size_t n_samples, double sigma_factor, double min, double max)
-
+RangedDistributionGaussian::RangedDistributionGaussian
Initializes Ranged distribution with given number of samples, sigma factor (range in standard deviations to take into account during sample generation) and limits (either RealLimits object or just min and max limits). By default n_samples = 5, sigma_factor = 2.0, while the limits are (-inf, +inf).
";
%feature("docstring") RangedDistributionGaussian::clone "RangedDistributionGaussian * RangedDistributionGaussian::clone() const override
-";
+RangedDistributionGaussian::clone";
%feature("docstring") RangedDistributionGaussian::~RangedDistributionGaussian "RangedDistributionGaussian::~RangedDistributionGaussian() override=default
-";
+RangedDistributionGaussian::~RangedDistributionGaussian";
%feature("docstring") RangedDistributionGaussian::name "std::string RangedDistributionGaussian::name() const override
-
+RangedDistributionGaussian::name
Returns distribution name for python-formatted text.
";
@@ -738,24 +738,24 @@ C++ includes: RangedDistributions.h
";
%feature("docstring") RangedDistributionLogNormal::RangedDistributionLogNormal "RangedDistributionLogNormal::RangedDistributionLogNormal()
-";
+RangedDistributionLogNormal::RangedDistributionLogNormal";
%feature("docstring") RangedDistributionLogNormal::RangedDistributionLogNormal "RangedDistributionLogNormal::RangedDistributionLogNormal(size_t n_samples, double sigma_factor, const RealLimits &limits=RealLimits::limitless())
-";
+RangedDistributionLogNormal::RangedDistributionLogNormal";
%feature("docstring") RangedDistributionLogNormal::RangedDistributionLogNormal "RangedDistributionLogNormal::RangedDistributionLogNormal(size_t n_samples, double sigma_factor, double min, double max)
-
+RangedDistributionLogNormal::RangedDistributionLogNormal
Initializes Ranged distribution with given number of samples, sigma factor (range in standard deviations to take into account during sample generation) and limits (either RealLimits object or just min and max limits). By default n_samples = 5, sigma_factor = 2.0, while the limits are (-inf, +inf).
";
%feature("docstring") RangedDistributionLogNormal::clone "RangedDistributionLogNormal * RangedDistributionLogNormal::clone() const override
-";
+RangedDistributionLogNormal::clone";
%feature("docstring") RangedDistributionLogNormal::~RangedDistributionLogNormal "RangedDistributionLogNormal::~RangedDistributionLogNormal() override=default
-";
+RangedDistributionLogNormal::~RangedDistributionLogNormal";
%feature("docstring") RangedDistributionLogNormal::name "std::string RangedDistributionLogNormal::name() const override
-
+RangedDistributionLogNormal::name
Returns distribution name for python-formatted text.
";
@@ -769,24 +769,24 @@ C++ includes: RangedDistributions.h
";
%feature("docstring") RangedDistributionLorentz::RangedDistributionLorentz "RangedDistributionLorentz::RangedDistributionLorentz()
-";
+RangedDistributionLorentz::RangedDistributionLorentz";
%feature("docstring") RangedDistributionLorentz::RangedDistributionLorentz "RangedDistributionLorentz::RangedDistributionLorentz(size_t n_samples, double hwhm_factor, const RealLimits &limits=RealLimits::limitless())
-";
+RangedDistributionLorentz::RangedDistributionLorentz";
%feature("docstring") RangedDistributionLorentz::RangedDistributionLorentz "RangedDistributionLorentz::RangedDistributionLorentz(size_t n_samples, double hwhm_factor, double min, double max)
-
+RangedDistributionLorentz::RangedDistributionLorentz
Initializes Ranged distribution with given number of samples, sigma factor (range in standard deviations to take into account during sample generation) and limits (either RealLimits object or just min and max limits). By default n_samples = 5, hwhm_factor = 2.0, while the limits are (-inf, +inf).
";
%feature("docstring") RangedDistributionLorentz::clone "RangedDistributionLorentz * RangedDistributionLorentz::clone() const override
-";
+RangedDistributionLorentz::clone";
%feature("docstring") RangedDistributionLorentz::~RangedDistributionLorentz "RangedDistributionLorentz::~RangedDistributionLorentz() override=default
-";
+RangedDistributionLorentz::~RangedDistributionLorentz";
%feature("docstring") RangedDistributionLorentz::name "std::string RangedDistributionLorentz::name() const override
-
+RangedDistributionLorentz::name
Returns distribution name for python-formatted text.
";
@@ -798,14 +798,14 @@ Returns distribution name for python-formatted text.
// File: namespaceNodeUtils.xml
-%feature("docstring") NodeUtils::ChildNodesOfType "std::vector<const T*> NodeUtils::ChildNodesOfType(const INode &node)
-";
+%feature("docstring") NodeUtils::ChildNodesOfType "std::vector< const T * > NodeUtils::ChildNodesOfType(const INode &node)
+NodeUtils::ChildNodesOfType";
-%feature("docstring") NodeUtils::OnlyChildOfType "const T* NodeUtils::OnlyChildOfType(const INode &node)
-";
+%feature("docstring") NodeUtils::OnlyChildOfType "const T * NodeUtils::OnlyChildOfType(const INode &node)
+NodeUtils::OnlyChildOfType";
-%feature("docstring") NodeUtils::AllDescendantsOfType "std::vector<const T*> NodeUtils::AllDescendantsOfType(const INode &node)
-";
+%feature("docstring") NodeUtils::AllDescendantsOfType "std::vector< const T * > NodeUtils::AllDescendantsOfType(const INode &node)
+NodeUtils::AllDescendantsOfType";
// File: DistributionHandler_8cpp.xml
diff --git a/auto/Wrap/doxygenSample.i b/auto/Wrap/doxygenSample.i
index 0ee325ad6cc..d975136c327 100644
--- a/auto/Wrap/doxygenSample.i
+++ b/auto/Wrap/doxygenSample.i
@@ -269,6 +269,9 @@ Returns the (approximate in some cases) radial size of the particle of this form
%feature("docstring") Box::formfactor_at_bottom "complex_t Box::formfactor_at_bottom(C3 q) const override
Box::formfactor_at_bottom";
+%feature("docstring") Box::validate "std::string Box::validate() const final
+Box::validate";
+
// File: classBoxNet.xml
%feature("docstring") BoxNet "";
diff --git a/auto/Wrap/libBornAgainParam.py b/auto/Wrap/libBornAgainParam.py
index 6b0e042338c..62ab86a6098 100644
--- a/auto/Wrap/libBornAgainParam.py
+++ b/auto/Wrap/libBornAgainParam.py
@@ -2068,7 +2068,7 @@ class INode(object):
__init__(INode self) -> INode
__init__(INode self, vdouble1d_t PValues) -> INode
INode::INode(std::vector< double > PValues)
-
+ INode::INode
"""
if self.__class__ == INode:
_self = None
@@ -2081,7 +2081,7 @@ class INode(object):
r"""
className(INode self) -> std::string
virtual std::string INode::className() const =0
-
+ INode::className
Returns the class name, to be hard-coded in each leaf class that inherits from INode.
"""
@@ -2090,8 +2090,8 @@ class INode(object):
def parDefs(self):
r"""
parDefs(INode self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >
- virtual std::vector<ParaMeta> INode::parDefs() const
-
+ virtual std::vector< ParaMeta > INode::parDefs() const
+ INode::parDefs
Returns the parameter definitions, to be hard-coded in each leaf class.
"""
@@ -2101,7 +2101,7 @@ class INode(object):
r"""
checkNodeArgs(INode self)
void INode::checkNodeArgs() const
-
+ INode::checkNodeArgs
Raises exception if a parameter value is invalid.
"""
@@ -2111,7 +2111,7 @@ class INode(object):
r"""
nodeChildren(INode self) -> swig_dummy_type_const_inode_vector
std::vector< const INode * > INode::nodeChildren() const
-
+ INode::nodeChildren
Returns all children.
"""
@@ -2121,7 +2121,7 @@ class INode(object):
r"""
nodeOffspring(INode self) -> swig_dummy_type_const_inode_vector
std::vector< const INode * > INode::nodeOffspring() const
-
+ INode::nodeOffspring
Returns all descendants.
"""
@@ -2153,8 +2153,8 @@ class IDistribution1D(libBornAgainBase.ICloneable, INode):
def clone(self):
r"""
clone(IDistribution1D self) -> IDistribution1D
- IDistribution1D* IDistribution1D::clone() const override=0
-
+ IDistribution1D * IDistribution1D::clone() const override=0
+ IDistribution1D::clone
"""
return _libBornAgainParam.IDistribution1D_clone(self)
@@ -2162,7 +2162,7 @@ class IDistribution1D(libBornAgainBase.ICloneable, INode):
r"""
probabilityDensity(IDistribution1D self, double x) -> double
virtual double IDistribution1D::probabilityDensity(double x) const =0
-
+ IDistribution1D::probabilityDensity
Returns the distribution-specific probability density for value x.
"""
@@ -2172,7 +2172,7 @@ class IDistribution1D(libBornAgainBase.ICloneable, INode):
r"""
mean(IDistribution1D self) -> double
virtual double IDistribution1D::mean() const =0
-
+ IDistribution1D::mean
Returns the distribution-specific mean.
"""
@@ -2182,7 +2182,7 @@ class IDistribution1D(libBornAgainBase.ICloneable, INode):
r"""
equidistantSamples(IDistribution1D self, size_t nbr_samples, double sigma_factor=0., RealLimits const & limits={}) -> std::vector< ParameterSample,std::allocator< ParameterSample > >
std::vector< ParameterSample > IDistribution1D::equidistantSamples(size_t nbr_samples, double sigma_factor=0., const RealLimits &limits={}) const
-
+ IDistribution1D::equidistantSamples
Returns equidistant samples, using intrinsic parameters, weighted with probabilityDensity().
"""
@@ -2192,7 +2192,7 @@ class IDistribution1D(libBornAgainBase.ICloneable, INode):
r"""
equidistantSamplesInRange(IDistribution1D self, size_t nbr_samples, double xmin, double xmax) -> std::vector< ParameterSample,std::allocator< ParameterSample > >
std::vector< ParameterSample > IDistribution1D::equidistantSamplesInRange(size_t nbr_samples, double xmin, double xmax) const
-
+ IDistribution1D::equidistantSamplesInRange
Returns equidistant samples from xmin to xmax, weighted with probabilityDensity().
"""
@@ -2201,8 +2201,8 @@ class IDistribution1D(libBornAgainBase.ICloneable, INode):
def equidistantPoints(self, *args):
r"""
equidistantPoints(IDistribution1D self, size_t nbr_samples, double sigma_factor, RealLimits const & limits={}) -> vdouble1d_t
- virtual std::vector<double> IDistribution1D::equidistantPoints(size_t nbr_samples, double sigma_factor, const RealLimits &limits={}) const =0
-
+ virtual std::vector< double > IDistribution1D::equidistantPoints(size_t nbr_samples, double sigma_factor, const RealLimits &limits={}) const =0
+ IDistribution1D::equidistantPoints
Returns equidistant interpolation points, with range computed in distribution-specific way from mean and width parameter, taking into account limits and sigma_factor.
"""
@@ -2212,7 +2212,7 @@ class IDistribution1D(libBornAgainBase.ICloneable, INode):
r"""
equidistantPointsInRange(IDistribution1D self, size_t nbr_samples, double xmin, double xmax) -> vdouble1d_t
std::vector< double > IDistribution1D::equidistantPointsInRange(size_t nbr_samples, double xmin, double xmax) const
-
+ IDistribution1D::equidistantPointsInRange
Returns equidistant interpolation points from xmin to xmax.
"""
@@ -2222,7 +2222,7 @@ class IDistribution1D(libBornAgainBase.ICloneable, INode):
r"""
isDelta(IDistribution1D self) -> bool
virtual bool IDistribution1D::isDelta() const =0
-
+ IDistribution1D::isDelta
Returns true if the distribution is in the limit case of a Dirac delta distribution.
"""
@@ -2251,15 +2251,15 @@ class DistributionGate(IDistribution1D):
__init__(DistributionGate self, double min, double max) -> DistributionGate
__init__(DistributionGate self) -> DistributionGate
DistributionGate::DistributionGate()
-
+ DistributionGate::DistributionGate
"""
_libBornAgainParam.DistributionGate_swiginit(self, _libBornAgainParam.new_DistributionGate(*args))
def clone(self):
r"""
clone(DistributionGate self) -> DistributionGate
- DistributionGate* DistributionGate::clone() const override
-
+ DistributionGate * DistributionGate::clone() const override
+ DistributionGate::clone
"""
return _libBornAgainParam.DistributionGate_clone(self)
@@ -2267,7 +2267,7 @@ class DistributionGate(IDistribution1D):
r"""
className(DistributionGate self) -> std::string
std::string DistributionGate::className() const final
-
+ DistributionGate::className
Returns the class name, to be hard-coded in each leaf class that inherits from INode.
"""
@@ -2276,8 +2276,8 @@ class DistributionGate(IDistribution1D):
def parDefs(self):
r"""
parDefs(DistributionGate self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >
- std::vector<ParaMeta> DistributionGate::parDefs() const final
-
+ std::vector< ParaMeta > DistributionGate::parDefs() const final
+ DistributionGate::parDefs
Returns the parameter definitions, to be hard-coded in each leaf class.
"""
@@ -2287,7 +2287,7 @@ class DistributionGate(IDistribution1D):
r"""
probabilityDensity(DistributionGate self, double x) -> double
double DistributionGate::probabilityDensity(double x) const override
-
+ DistributionGate::probabilityDensity
Returns the distribution-specific probability density for value x.
"""
@@ -2297,7 +2297,7 @@ class DistributionGate(IDistribution1D):
r"""
mean(DistributionGate self) -> double
double DistributionGate::mean() const override
-
+ DistributionGate::mean
Returns the distribution-specific mean.
"""
@@ -2307,7 +2307,7 @@ class DistributionGate(IDistribution1D):
r"""
min(DistributionGate self) -> double
double DistributionGate::min() const
-
+ DistributionGate::min
"""
return _libBornAgainParam.DistributionGate_min(self)
@@ -2315,7 +2315,7 @@ class DistributionGate(IDistribution1D):
r"""
max(DistributionGate self) -> double
double DistributionGate::max() const
-
+ DistributionGate::max
"""
return _libBornAgainParam.DistributionGate_max(self)
@@ -2323,7 +2323,7 @@ class DistributionGate(IDistribution1D):
r"""
equidistantPoints(DistributionGate self, size_t nbr_samples, double sigma_factor, RealLimits const & limits={}) -> vdouble1d_t
std::vector< double > DistributionGate::equidistantPoints(size_t nbr_samples, double sigma_factor, const RealLimits &limits={}) const override
-
+ DistributionGate::equidistantPoints
Returns list of sample values.
"""
@@ -2333,7 +2333,7 @@ class DistributionGate(IDistribution1D):
r"""
isDelta(DistributionGate self) -> bool
bool DistributionGate::isDelta() const override
-
+ DistributionGate::isDelta
Returns true if the distribution is in the limit case of a Dirac delta distribution.
"""
@@ -2362,15 +2362,15 @@ class DistributionLorentz(IDistribution1D):
__init__(DistributionLorentz self, double mean, double hwhm) -> DistributionLorentz
__init__(DistributionLorentz self) -> DistributionLorentz
DistributionLorentz::DistributionLorentz()
-
+ DistributionLorentz::DistributionLorentz
"""
_libBornAgainParam.DistributionLorentz_swiginit(self, _libBornAgainParam.new_DistributionLorentz(*args))
def clone(self):
r"""
clone(DistributionLorentz self) -> DistributionLorentz
- DistributionLorentz* DistributionLorentz::clone() const override
-
+ DistributionLorentz * DistributionLorentz::clone() const override
+ DistributionLorentz::clone
"""
return _libBornAgainParam.DistributionLorentz_clone(self)
@@ -2378,7 +2378,7 @@ class DistributionLorentz(IDistribution1D):
r"""
className(DistributionLorentz self) -> std::string
std::string DistributionLorentz::className() const final
-
+ DistributionLorentz::className
Returns the class name, to be hard-coded in each leaf class that inherits from INode.
"""
@@ -2387,8 +2387,8 @@ class DistributionLorentz(IDistribution1D):
def parDefs(self):
r"""
parDefs(DistributionLorentz self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >
- std::vector<ParaMeta> DistributionLorentz::parDefs() const final
-
+ std::vector< ParaMeta > DistributionLorentz::parDefs() const final
+ DistributionLorentz::parDefs
Returns the parameter definitions, to be hard-coded in each leaf class.
"""
@@ -2398,7 +2398,7 @@ class DistributionLorentz(IDistribution1D):
r"""
probabilityDensity(DistributionLorentz self, double x) -> double
double DistributionLorentz::probabilityDensity(double x) const override
-
+ DistributionLorentz::probabilityDensity
Returns the distribution-specific probability density for value x.
"""
@@ -2408,7 +2408,7 @@ class DistributionLorentz(IDistribution1D):
r"""
mean(DistributionLorentz self) -> double
double DistributionLorentz::mean() const override
-
+ DistributionLorentz::mean
Returns the distribution-specific mean.
"""
@@ -2418,7 +2418,7 @@ class DistributionLorentz(IDistribution1D):
r"""
hwhm(DistributionLorentz self) -> double
double DistributionLorentz::hwhm() const
-
+ DistributionLorentz::hwhm
"""
return _libBornAgainParam.DistributionLorentz_hwhm(self)
@@ -2426,7 +2426,7 @@ class DistributionLorentz(IDistribution1D):
r"""
equidistantPoints(DistributionLorentz self, size_t nbr_samples, double sigma_factor, RealLimits const & limits={}) -> vdouble1d_t
std::vector< double > DistributionLorentz::equidistantPoints(size_t nbr_samples, double sigma_factor, const RealLimits &limits={}) const override
-
+ DistributionLorentz::equidistantPoints
generate list of sample values
"""
@@ -2436,7 +2436,7 @@ class DistributionLorentz(IDistribution1D):
r"""
isDelta(DistributionLorentz self) -> bool
bool DistributionLorentz::isDelta() const override
-
+ DistributionLorentz::isDelta
Returns true if the distribution is in the limit case of a Dirac delta distribution.
"""
@@ -2465,15 +2465,15 @@ class DistributionGaussian(IDistribution1D):
__init__(DistributionGaussian self, double mean, double std_dev) -> DistributionGaussian
__init__(DistributionGaussian self) -> DistributionGaussian
DistributionGaussian::DistributionGaussian()
-
+ DistributionGaussian::DistributionGaussian
"""
_libBornAgainParam.DistributionGaussian_swiginit(self, _libBornAgainParam.new_DistributionGaussian(*args))
def clone(self):
r"""
clone(DistributionGaussian self) -> DistributionGaussian
- DistributionGaussian* DistributionGaussian::clone() const override
-
+ DistributionGaussian * DistributionGaussian::clone() const override
+ DistributionGaussian::clone
"""
return _libBornAgainParam.DistributionGaussian_clone(self)
@@ -2481,7 +2481,7 @@ class DistributionGaussian(IDistribution1D):
r"""
className(DistributionGaussian self) -> std::string
std::string DistributionGaussian::className() const final
-
+ DistributionGaussian::className
Returns the class name, to be hard-coded in each leaf class that inherits from INode.
"""
@@ -2490,8 +2490,8 @@ class DistributionGaussian(IDistribution1D):
def parDefs(self):
r"""
parDefs(DistributionGaussian self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >
- std::vector<ParaMeta> DistributionGaussian::parDefs() const final
-
+ std::vector< ParaMeta > DistributionGaussian::parDefs() const final
+ DistributionGaussian::parDefs
Returns the parameter definitions, to be hard-coded in each leaf class.
"""
@@ -2501,7 +2501,7 @@ class DistributionGaussian(IDistribution1D):
r"""
probabilityDensity(DistributionGaussian self, double x) -> double
double DistributionGaussian::probabilityDensity(double x) const override
-
+ DistributionGaussian::probabilityDensity
Returns the distribution-specific probability density for value x.
"""
@@ -2511,7 +2511,7 @@ class DistributionGaussian(IDistribution1D):
r"""
mean(DistributionGaussian self) -> double
double DistributionGaussian::mean() const override
-
+ DistributionGaussian::mean
Returns the distribution-specific mean.
"""
@@ -2521,7 +2521,7 @@ class DistributionGaussian(IDistribution1D):
r"""
getStdDev(DistributionGaussian self) -> double
double DistributionGaussian::getStdDev() const
-
+ DistributionGaussian::getStdDev
"""
return _libBornAgainParam.DistributionGaussian_getStdDev(self)
@@ -2529,7 +2529,7 @@ class DistributionGaussian(IDistribution1D):
r"""
equidistantPoints(DistributionGaussian self, size_t nbr_samples, double sigma_factor, RealLimits const & limits={}) -> vdouble1d_t
std::vector< double > DistributionGaussian::equidistantPoints(size_t nbr_samples, double sigma_factor, const RealLimits &limits={}) const override
-
+ DistributionGaussian::equidistantPoints
generate list of sample values
"""
@@ -2539,7 +2539,7 @@ class DistributionGaussian(IDistribution1D):
r"""
isDelta(DistributionGaussian self) -> bool
bool DistributionGaussian::isDelta() const override
-
+ DistributionGaussian::isDelta
Returns true if the distribution is in the limit case of a Dirac delta distribution.
"""
@@ -2567,15 +2567,15 @@ class DistributionLogNormal(IDistribution1D):
__init__(DistributionLogNormal self, vdouble1d_t P) -> DistributionLogNormal
__init__(DistributionLogNormal self, double median, double scale_param) -> DistributionLogNormal
DistributionLogNormal::DistributionLogNormal(double median, double scale_param)
-
+ DistributionLogNormal::DistributionLogNormal
"""
_libBornAgainParam.DistributionLogNormal_swiginit(self, _libBornAgainParam.new_DistributionLogNormal(*args))
def clone(self):
r"""
clone(DistributionLogNormal self) -> DistributionLogNormal
- DistributionLogNormal* DistributionLogNormal::clone() const override
-
+ DistributionLogNormal * DistributionLogNormal::clone() const override
+ DistributionLogNormal::clone
"""
return _libBornAgainParam.DistributionLogNormal_clone(self)
@@ -2583,7 +2583,7 @@ class DistributionLogNormal(IDistribution1D):
r"""
className(DistributionLogNormal self) -> std::string
std::string DistributionLogNormal::className() const final
-
+ DistributionLogNormal::className
Returns the class name, to be hard-coded in each leaf class that inherits from INode.
"""
@@ -2592,8 +2592,8 @@ class DistributionLogNormal(IDistribution1D):
def parDefs(self):
r"""
parDefs(DistributionLogNormal self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >
- std::vector<ParaMeta> DistributionLogNormal::parDefs() const final
-
+ std::vector< ParaMeta > DistributionLogNormal::parDefs() const final
+ DistributionLogNormal::parDefs
Returns the parameter definitions, to be hard-coded in each leaf class.
"""
@@ -2603,7 +2603,7 @@ class DistributionLogNormal(IDistribution1D):
r"""
probabilityDensity(DistributionLogNormal self, double x) -> double
double DistributionLogNormal::probabilityDensity(double x) const override
-
+ DistributionLogNormal::probabilityDensity
Returns the distribution-specific probability density for value x.
"""
@@ -2613,7 +2613,7 @@ class DistributionLogNormal(IDistribution1D):
r"""
mean(DistributionLogNormal self) -> double
double DistributionLogNormal::mean() const override
-
+ DistributionLogNormal::mean
Returns the distribution-specific mean.
"""
@@ -2623,7 +2623,7 @@ class DistributionLogNormal(IDistribution1D):
r"""
getMedian(DistributionLogNormal self) -> double
double DistributionLogNormal::getMedian() const
-
+ DistributionLogNormal::getMedian
"""
return _libBornAgainParam.DistributionLogNormal_getMedian(self)
@@ -2631,7 +2631,7 @@ class DistributionLogNormal(IDistribution1D):
r"""
getScalePar(DistributionLogNormal self) -> double
double DistributionLogNormal::getScalePar() const
-
+ DistributionLogNormal::getScalePar
"""
return _libBornAgainParam.DistributionLogNormal_getScalePar(self)
@@ -2639,7 +2639,7 @@ class DistributionLogNormal(IDistribution1D):
r"""
equidistantPoints(DistributionLogNormal self, size_t nbr_samples, double sigma_factor, RealLimits const & limits={}) -> vdouble1d_t
std::vector< double > DistributionLogNormal::equidistantPoints(size_t nbr_samples, double sigma_factor, const RealLimits &limits={}) const override
-
+ DistributionLogNormal::equidistantPoints
generate list of sample values
"""
@@ -2649,7 +2649,7 @@ class DistributionLogNormal(IDistribution1D):
r"""
isDelta(DistributionLogNormal self) -> bool
bool DistributionLogNormal::isDelta() const override
-
+ DistributionLogNormal::isDelta
Returns true if the distribution is in the limit case of a Dirac delta distribution.
"""
@@ -2678,15 +2678,15 @@ class DistributionCosine(IDistribution1D):
__init__(DistributionCosine self, double mean, double sigma) -> DistributionCosine
__init__(DistributionCosine self) -> DistributionCosine
DistributionCosine::DistributionCosine()
-
+ DistributionCosine::DistributionCosine
"""
_libBornAgainParam.DistributionCosine_swiginit(self, _libBornAgainParam.new_DistributionCosine(*args))
def clone(self):
r"""
clone(DistributionCosine self) -> DistributionCosine
- DistributionCosine* DistributionCosine::clone() const override
-
+ DistributionCosine * DistributionCosine::clone() const override
+ DistributionCosine::clone
"""
return _libBornAgainParam.DistributionCosine_clone(self)
@@ -2694,7 +2694,7 @@ class DistributionCosine(IDistribution1D):
r"""
className(DistributionCosine self) -> std::string
std::string DistributionCosine::className() const final
-
+ DistributionCosine::className
Returns the class name, to be hard-coded in each leaf class that inherits from INode.
"""
@@ -2703,8 +2703,8 @@ class DistributionCosine(IDistribution1D):
def parDefs(self):
r"""
parDefs(DistributionCosine self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >
- std::vector<ParaMeta> DistributionCosine::parDefs() const final
-
+ std::vector< ParaMeta > DistributionCosine::parDefs() const final
+ DistributionCosine::parDefs
Returns the parameter definitions, to be hard-coded in each leaf class.
"""
@@ -2714,7 +2714,7 @@ class DistributionCosine(IDistribution1D):
r"""
probabilityDensity(DistributionCosine self, double x) -> double
double DistributionCosine::probabilityDensity(double x) const override
-
+ DistributionCosine::probabilityDensity
Returns the distribution-specific probability density for value x.
"""
@@ -2724,7 +2724,7 @@ class DistributionCosine(IDistribution1D):
r"""
mean(DistributionCosine self) -> double
double DistributionCosine::mean() const override
-
+ DistributionCosine::mean
Returns the distribution-specific mean.
"""
@@ -2734,7 +2734,7 @@ class DistributionCosine(IDistribution1D):
r"""
sigma(DistributionCosine self) -> double
double DistributionCosine::sigma() const
-
+ DistributionCosine::sigma
"""
return _libBornAgainParam.DistributionCosine_sigma(self)
@@ -2742,7 +2742,7 @@ class DistributionCosine(IDistribution1D):
r"""
equidistantPoints(DistributionCosine self, size_t nbr_samples, double sigma_factor, RealLimits const & limits={}) -> vdouble1d_t
std::vector< double > DistributionCosine::equidistantPoints(size_t nbr_samples, double sigma_factor, const RealLimits &limits={}) const override
-
+ DistributionCosine::equidistantPoints
generate list of sample values
"""
@@ -2752,7 +2752,7 @@ class DistributionCosine(IDistribution1D):
r"""
isDelta(DistributionCosine self) -> bool
bool DistributionCosine::isDelta() const override
-
+ DistributionCosine::isDelta
Returns true if the distribution is in the limit case of a Dirac delta distribution.
"""
@@ -2781,15 +2781,15 @@ class DistributionTrapezoid(IDistribution1D):
__init__(DistributionTrapezoid self, double center, double left, double middle, double right) -> DistributionTrapezoid
__init__(DistributionTrapezoid self) -> DistributionTrapezoid
DistributionTrapezoid::DistributionTrapezoid()
-
+ DistributionTrapezoid::DistributionTrapezoid
"""
_libBornAgainParam.DistributionTrapezoid_swiginit(self, _libBornAgainParam.new_DistributionTrapezoid(*args))
def clone(self):
r"""
clone(DistributionTrapezoid self) -> DistributionTrapezoid
- DistributionTrapezoid* DistributionTrapezoid::clone() const override
-
+ DistributionTrapezoid * DistributionTrapezoid::clone() const override
+ DistributionTrapezoid::clone
"""
return _libBornAgainParam.DistributionTrapezoid_clone(self)
@@ -2797,7 +2797,7 @@ class DistributionTrapezoid(IDistribution1D):
r"""
className(DistributionTrapezoid self) -> std::string
std::string DistributionTrapezoid::className() const final
-
+ DistributionTrapezoid::className
Returns the class name, to be hard-coded in each leaf class that inherits from INode.
"""
@@ -2806,8 +2806,8 @@ class DistributionTrapezoid(IDistribution1D):
def parDefs(self):
r"""
parDefs(DistributionTrapezoid self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >
- std::vector<ParaMeta> DistributionTrapezoid::parDefs() const final
-
+ std::vector< ParaMeta > DistributionTrapezoid::parDefs() const final
+ DistributionTrapezoid::parDefs
Returns the parameter definitions, to be hard-coded in each leaf class.
"""
@@ -2817,7 +2817,7 @@ class DistributionTrapezoid(IDistribution1D):
r"""
probabilityDensity(DistributionTrapezoid self, double x) -> double
double DistributionTrapezoid::probabilityDensity(double x) const override
-
+ DistributionTrapezoid::probabilityDensity
Returns the distribution-specific probability density for value x.
"""
@@ -2827,7 +2827,7 @@ class DistributionTrapezoid(IDistribution1D):
r"""
mean(DistributionTrapezoid self) -> double
double DistributionTrapezoid::mean() const override
-
+ DistributionTrapezoid::mean
Returns the distribution-specific mean.
"""
@@ -2837,7 +2837,7 @@ class DistributionTrapezoid(IDistribution1D):
r"""
getLeftWidth(DistributionTrapezoid self) -> double
double DistributionTrapezoid::getLeftWidth() const
-
+ DistributionTrapezoid::getLeftWidth
"""
return _libBornAgainParam.DistributionTrapezoid_getLeftWidth(self)
@@ -2845,7 +2845,7 @@ class DistributionTrapezoid(IDistribution1D):
r"""
getMiddleWidth(DistributionTrapezoid self) -> double
double DistributionTrapezoid::getMiddleWidth() const
-
+ DistributionTrapezoid::getMiddleWidth
"""
return _libBornAgainParam.DistributionTrapezoid_getMiddleWidth(self)
@@ -2853,7 +2853,7 @@ class DistributionTrapezoid(IDistribution1D):
r"""
getRightWidth(DistributionTrapezoid self) -> double
double DistributionTrapezoid::getRightWidth() const
-
+ DistributionTrapezoid::getRightWidth
"""
return _libBornAgainParam.DistributionTrapezoid_getRightWidth(self)
@@ -2861,7 +2861,7 @@ class DistributionTrapezoid(IDistribution1D):
r"""
equidistantPoints(DistributionTrapezoid self, size_t nbr_samples, double sigma_factor, RealLimits const & limits={}) -> vdouble1d_t
std::vector< double > DistributionTrapezoid::equidistantPoints(size_t nbr_samples, double sigma_factor, const RealLimits &limits={}) const override
-
+ DistributionTrapezoid::equidistantPoints
generate list of sample values
"""
@@ -2871,7 +2871,7 @@ class DistributionTrapezoid(IDistribution1D):
r"""
isDelta(DistributionTrapezoid self) -> bool
bool DistributionTrapezoid::isDelta() const override
-
+ DistributionTrapezoid::isDelta
Returns true if the distribution is in the limit case of a Dirac delta distribution.
"""
@@ -2908,7 +2908,7 @@ class ParameterDistribution(object):
__init__(ParameterDistribution self, ParameterDistribution::WhichParameter whichParameter, IDistribution1D distribution, size_t nbr_samples, double xmin, double xmax) -> ParameterDistribution
__init__(ParameterDistribution self, ParameterDistribution other) -> ParameterDistribution
ParameterDistribution::ParameterDistribution(const ParameterDistribution &other)
-
+ ParameterDistribution::ParameterDistribution
"""
_libBornAgainParam.ParameterDistribution_swiginit(self, _libBornAgainParam.new_ParameterDistribution(*args))
__swig_destroy__ = _libBornAgainParam.delete_ParameterDistribution
@@ -2917,7 +2917,7 @@ class ParameterDistribution(object):
r"""
whichParameter(ParameterDistribution self) -> ParameterDistribution::WhichParameter
ParameterDistribution::WhichParameter ParameterDistribution::whichParameter() const
-
+ ParameterDistribution::whichParameter
"""
return _libBornAgainParam.ParameterDistribution_whichParameter(self)
@@ -2925,7 +2925,7 @@ class ParameterDistribution(object):
r"""
whichParameterAsPyEnum(ParameterDistribution self) -> std::string
std::string ParameterDistribution::whichParameterAsPyEnum() const
-
+ ParameterDistribution::whichParameterAsPyEnum
"""
return _libBornAgainParam.ParameterDistribution_whichParameterAsPyEnum(self)
@@ -2933,7 +2933,7 @@ class ParameterDistribution(object):
r"""
nDraws(ParameterDistribution self) -> size_t
size_t ParameterDistribution::nDraws() const
-
+ ParameterDistribution::nDraws
get number of samples for this distribution
"""
@@ -2943,7 +2943,7 @@ class ParameterDistribution(object):
r"""
sigmaFactor(ParameterDistribution self) -> double
double ParameterDistribution::sigmaFactor() const
-
+ ParameterDistribution::sigmaFactor
get the sigma factor
"""
@@ -2954,7 +2954,7 @@ class ParameterDistribution(object):
getDistribution(ParameterDistribution self) -> IDistribution1D
getDistribution(ParameterDistribution self) -> IDistribution1D
IDistribution1D * ParameterDistribution::getDistribution()
-
+ ParameterDistribution::getDistribution
"""
return _libBornAgainParam.ParameterDistribution_getDistribution(self, *args)
@@ -2962,7 +2962,7 @@ class ParameterDistribution(object):
r"""
generateSamples(ParameterDistribution self) -> std::vector< ParameterSample,std::allocator< ParameterSample > >
std::vector< ParameterSample > ParameterDistribution::generateSamples() const
-
+ ParameterDistribution::generateSamples
generate list of sampled values with their weight
"""
@@ -2972,7 +2972,7 @@ class ParameterDistribution(object):
r"""
getLimits(ParameterDistribution self) -> RealLimits
RealLimits ParameterDistribution::getLimits() const
-
+ ParameterDistribution::getLimits
"""
return _libBornAgainParam.ParameterDistribution_getLimits(self)
@@ -2980,7 +2980,7 @@ class ParameterDistribution(object):
r"""
getMinValue(ParameterDistribution self) -> double
double ParameterDistribution::getMinValue() const
-
+ ParameterDistribution::getMinValue
"""
return _libBornAgainParam.ParameterDistribution_getMinValue(self)
@@ -2988,7 +2988,7 @@ class ParameterDistribution(object):
r"""
getMaxValue(ParameterDistribution self) -> double
double ParameterDistribution::getMaxValue() const
-
+ ParameterDistribution::getMaxValue
"""
return _libBornAgainParam.ParameterDistribution_getMaxValue(self)
@@ -3014,7 +3014,7 @@ class RangedDistributionGate(object):
__init__(RangedDistributionGate self, size_t n_samples, double sigma_factor, RealLimits const & limits=RealLimits::limitless()) -> RangedDistributionGate
__init__(RangedDistributionGate self, size_t n_samples, double sigma_factor, double min, double max) -> RangedDistributionGate
RangedDistributionGate::RangedDistributionGate(size_t n_samples, double sigma_factor, double min, double max)
-
+ RangedDistributionGate::RangedDistributionGate
Initializes Ranged distribution with given number of samples, sigma factor (range in standard deviations to take into account during sample generation) and limits (either RealLimits object or just min and max limits). By default n_samples = 5, sigma_factor = 2.0, while the limits are (-inf, +inf).
"""
@@ -3024,7 +3024,7 @@ class RangedDistributionGate(object):
r"""
clone(RangedDistributionGate self) -> RangedDistributionGate
RangedDistributionGate * RangedDistributionGate::clone() const override
-
+ RangedDistributionGate::clone
"""
return _libBornAgainParam.RangedDistributionGate_clone(self)
__swig_destroy__ = _libBornAgainParam.delete_RangedDistributionGate
@@ -3033,7 +3033,7 @@ class RangedDistributionGate(object):
r"""
name(RangedDistributionGate self) -> std::string
std::string RangedDistributionGate::name() const override
-
+ RangedDistributionGate::name
Returns distribution name for python-formatted text.
"""
@@ -3061,7 +3061,7 @@ class RangedDistributionLorentz(object):
__init__(RangedDistributionLorentz self, size_t n_samples, double hwhm_factor, RealLimits const & limits=RealLimits::limitless()) -> RangedDistributionLorentz
__init__(RangedDistributionLorentz self, size_t n_samples, double hwhm_factor, double min, double max) -> RangedDistributionLorentz
RangedDistributionLorentz::RangedDistributionLorentz(size_t n_samples, double hwhm_factor, double min, double max)
-
+ RangedDistributionLorentz::RangedDistributionLorentz
Initializes Ranged distribution with given number of samples, sigma factor (range in standard deviations to take into account during sample generation) and limits (either RealLimits object or just min and max limits). By default n_samples = 5, hwhm_factor = 2.0, while the limits are (-inf, +inf).
"""
@@ -3071,7 +3071,7 @@ class RangedDistributionLorentz(object):
r"""
clone(RangedDistributionLorentz self) -> RangedDistributionLorentz
RangedDistributionLorentz * RangedDistributionLorentz::clone() const override
-
+ RangedDistributionLorentz::clone
"""
return _libBornAgainParam.RangedDistributionLorentz_clone(self)
__swig_destroy__ = _libBornAgainParam.delete_RangedDistributionLorentz
@@ -3080,7 +3080,7 @@ class RangedDistributionLorentz(object):
r"""
name(RangedDistributionLorentz self) -> std::string
std::string RangedDistributionLorentz::name() const override
-
+ RangedDistributionLorentz::name
Returns distribution name for python-formatted text.
"""
@@ -3108,7 +3108,7 @@ class RangedDistributionGaussian(object):
__init__(RangedDistributionGaussian self, size_t n_samples, double sigma_factor, RealLimits const & limits=RealLimits::limitless()) -> RangedDistributionGaussian
__init__(RangedDistributionGaussian self, size_t n_samples, double sigma_factor, double min, double max) -> RangedDistributionGaussian
RangedDistributionGaussian::RangedDistributionGaussian(size_t n_samples, double sigma_factor, double min, double max)
-
+ RangedDistributionGaussian::RangedDistributionGaussian
Initializes Ranged distribution with given number of samples, sigma factor (range in standard deviations to take into account during sample generation) and limits (either RealLimits object or just min and max limits). By default n_samples = 5, sigma_factor = 2.0, while the limits are (-inf, +inf).
"""
@@ -3118,7 +3118,7 @@ class RangedDistributionGaussian(object):
r"""
clone(RangedDistributionGaussian self) -> RangedDistributionGaussian
RangedDistributionGaussian * RangedDistributionGaussian::clone() const override
-
+ RangedDistributionGaussian::clone
"""
return _libBornAgainParam.RangedDistributionGaussian_clone(self)
__swig_destroy__ = _libBornAgainParam.delete_RangedDistributionGaussian
@@ -3127,7 +3127,7 @@ class RangedDistributionGaussian(object):
r"""
name(RangedDistributionGaussian self) -> std::string
std::string RangedDistributionGaussian::name() const override
-
+ RangedDistributionGaussian::name
Returns distribution name for python-formatted text.
"""
@@ -3155,7 +3155,7 @@ class RangedDistributionLogNormal(object):
__init__(RangedDistributionLogNormal self, size_t n_samples, double sigma_factor, RealLimits const & limits=RealLimits::limitless()) -> RangedDistributionLogNormal
__init__(RangedDistributionLogNormal self, size_t n_samples, double sigma_factor, double min, double max) -> RangedDistributionLogNormal
RangedDistributionLogNormal::RangedDistributionLogNormal(size_t n_samples, double sigma_factor, double min, double max)
-
+ RangedDistributionLogNormal::RangedDistributionLogNormal
Initializes Ranged distribution with given number of samples, sigma factor (range in standard deviations to take into account during sample generation) and limits (either RealLimits object or just min and max limits). By default n_samples = 5, sigma_factor = 2.0, while the limits are (-inf, +inf).
"""
@@ -3165,7 +3165,7 @@ class RangedDistributionLogNormal(object):
r"""
clone(RangedDistributionLogNormal self) -> RangedDistributionLogNormal
RangedDistributionLogNormal * RangedDistributionLogNormal::clone() const override
-
+ RangedDistributionLogNormal::clone
"""
return _libBornAgainParam.RangedDistributionLogNormal_clone(self)
__swig_destroy__ = _libBornAgainParam.delete_RangedDistributionLogNormal
@@ -3174,7 +3174,7 @@ class RangedDistributionLogNormal(object):
r"""
name(RangedDistributionLogNormal self) -> std::string
std::string RangedDistributionLogNormal::name() const override
-
+ RangedDistributionLogNormal::name
Returns distribution name for python-formatted text.
"""
@@ -3202,7 +3202,7 @@ class RangedDistributionCosine(object):
__init__(RangedDistributionCosine self, size_t n_samples, double sigma_factor, RealLimits const & limits=RealLimits::limitless()) -> RangedDistributionCosine
__init__(RangedDistributionCosine self, size_t n_samples, double sigma_factor, double min, double max) -> RangedDistributionCosine
RangedDistributionCosine::RangedDistributionCosine(size_t n_samples, double sigma_factor, double min, double max)
-
+ RangedDistributionCosine::RangedDistributionCosine
Initializes Ranged distribution with given number of samples, sigma factor (range in standard deviations to take into account during sample generation) and limits (either RealLimits object or just min and max limits). By default n_samples = 5, sigma_factor = 2.0, while the limits are (-inf, +inf).
"""
@@ -3212,7 +3212,7 @@ class RangedDistributionCosine(object):
r"""
clone(RangedDistributionCosine self) -> RangedDistributionCosine
RangedDistributionCosine * RangedDistributionCosine::clone() const override
-
+ RangedDistributionCosine::clone
"""
return _libBornAgainParam.RangedDistributionCosine_clone(self)
__swig_destroy__ = _libBornAgainParam.delete_RangedDistributionCosine
@@ -3221,7 +3221,7 @@ class RangedDistributionCosine(object):
r"""
name(RangedDistributionCosine self) -> std::string
std::string RangedDistributionCosine::name() const override
-
+ RangedDistributionCosine::name
Returns distribution name for python-formatted text.
"""
@@ -3247,7 +3247,7 @@ class ParameterSample(object):
r"""
__init__(ParameterSample self, double _value, double _weight=1) -> ParameterSample
ParameterSample::ParameterSample(double _value, double _weight=1)
-
+ ParameterSample::ParameterSample
"""
_libBornAgainParam.ParameterSample_swiginit(self, _libBornAgainParam.new_ParameterSample(_value, _weight))
value = property(_libBornAgainParam.ParameterSample_value_get, _libBornAgainParam.ParameterSample_value_set, doc=r"""value : double""")
diff --git a/auto/Wrap/libBornAgainParam_wrap.cpp b/auto/Wrap/libBornAgainParam_wrap.cpp
index 385736141f7..24c08e57b46 100644
--- a/auto/Wrap/libBornAgainParam_wrap.cpp
+++ b/auto/Wrap/libBornAgainParam_wrap.cpp
@@ -34783,45 +34783,45 @@ static PyMethodDef SwigMethods[] = {
"INode()\n"
"new_INode(PyObject * _self, vdouble1d_t PValues) -> INode\n"
"INode::INode(std::vector< double > PValues)\n"
- "\n"
+ "INode::INode\n"
""},
{ "delete_INode", _wrap_delete_INode, METH_O, "\n"
"delete_INode(INode self)\n"
"virtual INode::~INode()=default\n"
- "\n"
+ "INode::~INode\n"
""},
{ "INode_className", _wrap_INode_className, METH_O, "\n"
"INode_className(INode self) -> std::string\n"
"virtual std::string INode::className() const =0\n"
- "\n"
+ "INode::className\n"
"Returns the class name, to be hard-coded in each leaf class that inherits from INode. \n"
"\n"
""},
{ "INode_parDefs", _wrap_INode_parDefs, METH_O, "\n"
"INode_parDefs(INode self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >\n"
- "virtual std::vector<ParaMeta> INode::parDefs() const\n"
- "\n"
+ "virtual std::vector< ParaMeta > INode::parDefs() const\n"
+ "INode::parDefs\n"
"Returns the parameter definitions, to be hard-coded in each leaf class. \n"
"\n"
""},
{ "INode_checkNodeArgs", _wrap_INode_checkNodeArgs, METH_O, "\n"
"INode_checkNodeArgs(INode self)\n"
"void INode::checkNodeArgs() const\n"
- "\n"
+ "INode::checkNodeArgs\n"
"Raises exception if a parameter value is invalid. \n"
"\n"
""},
{ "INode_nodeChildren", _wrap_INode_nodeChildren, METH_O, "\n"
"INode_nodeChildren(INode self) -> swig_dummy_type_const_inode_vector\n"
"std::vector< const INode * > INode::nodeChildren() const\n"
- "\n"
+ "INode::nodeChildren\n"
"Returns all children. \n"
"\n"
""},
{ "INode_nodeOffspring", _wrap_INode_nodeOffspring, METH_O, "\n"
"INode_nodeOffspring(INode self) -> swig_dummy_type_const_inode_vector\n"
"std::vector< const INode * > INode::nodeOffspring() const\n"
- "\n"
+ "INode::nodeOffspring\n"
"Returns all descendants. \n"
"\n"
""},
@@ -34830,55 +34830,55 @@ static PyMethodDef SwigMethods[] = {
{ "INode_swiginit", INode_swiginit, METH_VARARGS, NULL},
{ "IDistribution1D_clone", _wrap_IDistribution1D_clone, METH_O, "\n"
"IDistribution1D_clone(IDistribution1D self) -> IDistribution1D\n"
- "IDistribution1D* IDistribution1D::clone() const override=0\n"
- "\n"
+ "IDistribution1D * IDistribution1D::clone() const override=0\n"
+ "IDistribution1D::clone\n"
""},
{ "IDistribution1D_probabilityDensity", _wrap_IDistribution1D_probabilityDensity, METH_VARARGS, "\n"
"IDistribution1D_probabilityDensity(IDistribution1D self, double x) -> double\n"
"virtual double IDistribution1D::probabilityDensity(double x) const =0\n"
- "\n"
+ "IDistribution1D::probabilityDensity\n"
"Returns the distribution-specific probability density for value x. \n"
"\n"
""},
{ "IDistribution1D_mean", _wrap_IDistribution1D_mean, METH_O, "\n"
"IDistribution1D_mean(IDistribution1D self) -> double\n"
"virtual double IDistribution1D::mean() const =0\n"
- "\n"
+ "IDistribution1D::mean\n"
"Returns the distribution-specific mean. \n"
"\n"
""},
{ "IDistribution1D_equidistantSamples", _wrap_IDistribution1D_equidistantSamples, METH_VARARGS, "\n"
"IDistribution1D_equidistantSamples(IDistribution1D self, size_t nbr_samples, double sigma_factor=0., RealLimits const & limits={}) -> std::vector< ParameterSample,std::allocator< ParameterSample > >\n"
"std::vector< ParameterSample > IDistribution1D::equidistantSamples(size_t nbr_samples, double sigma_factor=0., const RealLimits &limits={}) const\n"
- "\n"
+ "IDistribution1D::equidistantSamples\n"
"Returns equidistant samples, using intrinsic parameters, weighted with probabilityDensity(). \n"
"\n"
""},
{ "IDistribution1D_equidistantSamplesInRange", _wrap_IDistribution1D_equidistantSamplesInRange, METH_VARARGS, "\n"
"IDistribution1D_equidistantSamplesInRange(IDistribution1D self, size_t nbr_samples, double xmin, double xmax) -> std::vector< ParameterSample,std::allocator< ParameterSample > >\n"
"std::vector< ParameterSample > IDistribution1D::equidistantSamplesInRange(size_t nbr_samples, double xmin, double xmax) const\n"
- "\n"
+ "IDistribution1D::equidistantSamplesInRange\n"
"Returns equidistant samples from xmin to xmax, weighted with probabilityDensity(). \n"
"\n"
""},
{ "IDistribution1D_equidistantPoints", _wrap_IDistribution1D_equidistantPoints, METH_VARARGS, "\n"
"IDistribution1D_equidistantPoints(IDistribution1D self, size_t nbr_samples, double sigma_factor, RealLimits const & limits={}) -> vdouble1d_t\n"
- "virtual std::vector<double> IDistribution1D::equidistantPoints(size_t nbr_samples, double sigma_factor, const RealLimits &limits={}) const =0\n"
- "\n"
+ "virtual std::vector< double > IDistribution1D::equidistantPoints(size_t nbr_samples, double sigma_factor, const RealLimits &limits={}) const =0\n"
+ "IDistribution1D::equidistantPoints\n"
"Returns equidistant interpolation points, with range computed in distribution-specific way from mean and width parameter, taking into account limits and sigma_factor. \n"
"\n"
""},
{ "IDistribution1D_equidistantPointsInRange", _wrap_IDistribution1D_equidistantPointsInRange, METH_VARARGS, "\n"
"IDistribution1D_equidistantPointsInRange(IDistribution1D self, size_t nbr_samples, double xmin, double xmax) -> vdouble1d_t\n"
"std::vector< double > IDistribution1D::equidistantPointsInRange(size_t nbr_samples, double xmin, double xmax) const\n"
- "\n"
+ "IDistribution1D::equidistantPointsInRange\n"
"Returns equidistant interpolation points from xmin to xmax. \n"
"\n"
""},
{ "IDistribution1D_isDelta", _wrap_IDistribution1D_isDelta, METH_O, "\n"
"IDistribution1D_isDelta(IDistribution1D self) -> bool\n"
"virtual bool IDistribution1D::isDelta() const =0\n"
- "\n"
+ "IDistribution1D::isDelta\n"
"Returns true if the distribution is in the limit case of a Dirac delta distribution. \n"
"\n"
""},
@@ -34889,62 +34889,62 @@ static PyMethodDef SwigMethods[] = {
"DistributionGate(double min, double max)\n"
"new_DistributionGate() -> DistributionGate\n"
"DistributionGate::DistributionGate()\n"
- "\n"
+ "DistributionGate::DistributionGate\n"
""},
{ "DistributionGate_clone", _wrap_DistributionGate_clone, METH_O, "\n"
"DistributionGate_clone(DistributionGate self) -> DistributionGate\n"
- "DistributionGate* DistributionGate::clone() const override\n"
- "\n"
+ "DistributionGate * DistributionGate::clone() const override\n"
+ "DistributionGate::clone\n"
""},
{ "DistributionGate_className", _wrap_DistributionGate_className, METH_O, "\n"
"DistributionGate_className(DistributionGate self) -> std::string\n"
"std::string DistributionGate::className() const final\n"
- "\n"
+ "DistributionGate::className\n"
"Returns the class name, to be hard-coded in each leaf class that inherits from INode. \n"
"\n"
""},
{ "DistributionGate_parDefs", _wrap_DistributionGate_parDefs, METH_O, "\n"
"DistributionGate_parDefs(DistributionGate self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >\n"
- "std::vector<ParaMeta> DistributionGate::parDefs() const final\n"
- "\n"
+ "std::vector< ParaMeta > DistributionGate::parDefs() const final\n"
+ "DistributionGate::parDefs\n"
"Returns the parameter definitions, to be hard-coded in each leaf class. \n"
"\n"
""},
{ "DistributionGate_probabilityDensity", _wrap_DistributionGate_probabilityDensity, METH_VARARGS, "\n"
"DistributionGate_probabilityDensity(DistributionGate self, double x) -> double\n"
"double DistributionGate::probabilityDensity(double x) const override\n"
- "\n"
+ "DistributionGate::probabilityDensity\n"
"Returns the distribution-specific probability density for value x. \n"
"\n"
""},
{ "DistributionGate_mean", _wrap_DistributionGate_mean, METH_O, "\n"
"DistributionGate_mean(DistributionGate self) -> double\n"
"double DistributionGate::mean() const override\n"
- "\n"
+ "DistributionGate::mean\n"
"Returns the distribution-specific mean. \n"
"\n"
""},
{ "DistributionGate_min", _wrap_DistributionGate_min, METH_O, "\n"
"DistributionGate_min(DistributionGate self) -> double\n"
"double DistributionGate::min() const\n"
- "\n"
+ "DistributionGate::min\n"
""},
{ "DistributionGate_max", _wrap_DistributionGate_max, METH_O, "\n"
"DistributionGate_max(DistributionGate self) -> double\n"
"double DistributionGate::max() const\n"
- "\n"
+ "DistributionGate::max\n"
""},
{ "DistributionGate_equidistantPoints", _wrap_DistributionGate_equidistantPoints, METH_VARARGS, "\n"
"DistributionGate_equidistantPoints(DistributionGate self, size_t nbr_samples, double sigma_factor, RealLimits const & limits={}) -> vdouble1d_t\n"
"std::vector< double > DistributionGate::equidistantPoints(size_t nbr_samples, double sigma_factor, const RealLimits &limits={}) const override\n"
- "\n"
+ "DistributionGate::equidistantPoints\n"
"Returns list of sample values. \n"
"\n"
""},
{ "DistributionGate_isDelta", _wrap_DistributionGate_isDelta, METH_O, "\n"
"DistributionGate_isDelta(DistributionGate self) -> bool\n"
"bool DistributionGate::isDelta() const override\n"
- "\n"
+ "DistributionGate::isDelta\n"
"Returns true if the distribution is in the limit case of a Dirac delta distribution. \n"
"\n"
""},
@@ -34956,57 +34956,57 @@ static PyMethodDef SwigMethods[] = {
"DistributionLorentz(double mean, double hwhm)\n"
"new_DistributionLorentz() -> DistributionLorentz\n"
"DistributionLorentz::DistributionLorentz()\n"
- "\n"
+ "DistributionLorentz::DistributionLorentz\n"
""},
{ "DistributionLorentz_clone", _wrap_DistributionLorentz_clone, METH_O, "\n"
"DistributionLorentz_clone(DistributionLorentz self) -> DistributionLorentz\n"
- "DistributionLorentz* DistributionLorentz::clone() const override\n"
- "\n"
+ "DistributionLorentz * DistributionLorentz::clone() const override\n"
+ "DistributionLorentz::clone\n"
""},
{ "DistributionLorentz_className", _wrap_DistributionLorentz_className, METH_O, "\n"
"DistributionLorentz_className(DistributionLorentz self) -> std::string\n"
"std::string DistributionLorentz::className() const final\n"
- "\n"
+ "DistributionLorentz::className\n"
"Returns the class name, to be hard-coded in each leaf class that inherits from INode. \n"
"\n"
""},
{ "DistributionLorentz_parDefs", _wrap_DistributionLorentz_parDefs, METH_O, "\n"
"DistributionLorentz_parDefs(DistributionLorentz self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >\n"
- "std::vector<ParaMeta> DistributionLorentz::parDefs() const final\n"
- "\n"
+ "std::vector< ParaMeta > DistributionLorentz::parDefs() const final\n"
+ "DistributionLorentz::parDefs\n"
"Returns the parameter definitions, to be hard-coded in each leaf class. \n"
"\n"
""},
{ "DistributionLorentz_probabilityDensity", _wrap_DistributionLorentz_probabilityDensity, METH_VARARGS, "\n"
"DistributionLorentz_probabilityDensity(DistributionLorentz self, double x) -> double\n"
"double DistributionLorentz::probabilityDensity(double x) const override\n"
- "\n"
+ "DistributionLorentz::probabilityDensity\n"
"Returns the distribution-specific probability density for value x. \n"
"\n"
""},
{ "DistributionLorentz_mean", _wrap_DistributionLorentz_mean, METH_O, "\n"
"DistributionLorentz_mean(DistributionLorentz self) -> double\n"
"double DistributionLorentz::mean() const override\n"
- "\n"
+ "DistributionLorentz::mean\n"
"Returns the distribution-specific mean. \n"
"\n"
""},
{ "DistributionLorentz_hwhm", _wrap_DistributionLorentz_hwhm, METH_O, "\n"
"DistributionLorentz_hwhm(DistributionLorentz self) -> double\n"
"double DistributionLorentz::hwhm() const\n"
- "\n"
+ "DistributionLorentz::hwhm\n"
""},
{ "DistributionLorentz_equidistantPoints", _wrap_DistributionLorentz_equidistantPoints, METH_VARARGS, "\n"
"DistributionLorentz_equidistantPoints(DistributionLorentz self, size_t nbr_samples, double sigma_factor, RealLimits const & limits={}) -> vdouble1d_t\n"
"std::vector< double > DistributionLorentz::equidistantPoints(size_t nbr_samples, double sigma_factor, const RealLimits &limits={}) const override\n"
- "\n"
+ "DistributionLorentz::equidistantPoints\n"
"generate list of sample values \n"
"\n"
""},
{ "DistributionLorentz_isDelta", _wrap_DistributionLorentz_isDelta, METH_O, "\n"
"DistributionLorentz_isDelta(DistributionLorentz self) -> bool\n"
"bool DistributionLorentz::isDelta() const override\n"
- "\n"
+ "DistributionLorentz::isDelta\n"
"Returns true if the distribution is in the limit case of a Dirac delta distribution. \n"
"\n"
""},
@@ -35018,57 +35018,57 @@ static PyMethodDef SwigMethods[] = {
"DistributionGaussian(double mean, double std_dev)\n"
"new_DistributionGaussian() -> DistributionGaussian\n"
"DistributionGaussian::DistributionGaussian()\n"
- "\n"
+ "DistributionGaussian::DistributionGaussian\n"
""},
{ "DistributionGaussian_clone", _wrap_DistributionGaussian_clone, METH_O, "\n"
"DistributionGaussian_clone(DistributionGaussian self) -> DistributionGaussian\n"
- "DistributionGaussian* DistributionGaussian::clone() const override\n"
- "\n"
+ "DistributionGaussian * DistributionGaussian::clone() const override\n"
+ "DistributionGaussian::clone\n"
""},
{ "DistributionGaussian_className", _wrap_DistributionGaussian_className, METH_O, "\n"
"DistributionGaussian_className(DistributionGaussian self) -> std::string\n"
"std::string DistributionGaussian::className() const final\n"
- "\n"
+ "DistributionGaussian::className\n"
"Returns the class name, to be hard-coded in each leaf class that inherits from INode. \n"
"\n"
""},
{ "DistributionGaussian_parDefs", _wrap_DistributionGaussian_parDefs, METH_O, "\n"
"DistributionGaussian_parDefs(DistributionGaussian self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >\n"
- "std::vector<ParaMeta> DistributionGaussian::parDefs() const final\n"
- "\n"
+ "std::vector< ParaMeta > DistributionGaussian::parDefs() const final\n"
+ "DistributionGaussian::parDefs\n"
"Returns the parameter definitions, to be hard-coded in each leaf class. \n"
"\n"
""},
{ "DistributionGaussian_probabilityDensity", _wrap_DistributionGaussian_probabilityDensity, METH_VARARGS, "\n"
"DistributionGaussian_probabilityDensity(DistributionGaussian self, double x) -> double\n"
"double DistributionGaussian::probabilityDensity(double x) const override\n"
- "\n"
+ "DistributionGaussian::probabilityDensity\n"
"Returns the distribution-specific probability density for value x. \n"
"\n"
""},
{ "DistributionGaussian_mean", _wrap_DistributionGaussian_mean, METH_O, "\n"
"DistributionGaussian_mean(DistributionGaussian self) -> double\n"
"double DistributionGaussian::mean() const override\n"
- "\n"
+ "DistributionGaussian::mean\n"
"Returns the distribution-specific mean. \n"
"\n"
""},
{ "DistributionGaussian_getStdDev", _wrap_DistributionGaussian_getStdDev, METH_O, "\n"
"DistributionGaussian_getStdDev(DistributionGaussian self) -> double\n"
"double DistributionGaussian::getStdDev() const\n"
- "\n"
+ "DistributionGaussian::getStdDev\n"
""},
{ "DistributionGaussian_equidistantPoints", _wrap_DistributionGaussian_equidistantPoints, METH_VARARGS, "\n"
"DistributionGaussian_equidistantPoints(DistributionGaussian self, size_t nbr_samples, double sigma_factor, RealLimits const & limits={}) -> vdouble1d_t\n"
"std::vector< double > DistributionGaussian::equidistantPoints(size_t nbr_samples, double sigma_factor, const RealLimits &limits={}) const override\n"
- "\n"
+ "DistributionGaussian::equidistantPoints\n"
"generate list of sample values \n"
"\n"
""},
{ "DistributionGaussian_isDelta", _wrap_DistributionGaussian_isDelta, METH_O, "\n"
"DistributionGaussian_isDelta(DistributionGaussian self) -> bool\n"
"bool DistributionGaussian::isDelta() const override\n"
- "\n"
+ "DistributionGaussian::isDelta\n"
"Returns true if the distribution is in the limit case of a Dirac delta distribution. \n"
"\n"
""},
@@ -35079,62 +35079,62 @@ static PyMethodDef SwigMethods[] = {
"DistributionLogNormal(vdouble1d_t P)\n"
"new_DistributionLogNormal(double median, double scale_param) -> DistributionLogNormal\n"
"DistributionLogNormal::DistributionLogNormal(double median, double scale_param)\n"
- "\n"
+ "DistributionLogNormal::DistributionLogNormal\n"
""},
{ "DistributionLogNormal_clone", _wrap_DistributionLogNormal_clone, METH_O, "\n"
"DistributionLogNormal_clone(DistributionLogNormal self) -> DistributionLogNormal\n"
- "DistributionLogNormal* DistributionLogNormal::clone() const override\n"
- "\n"
+ "DistributionLogNormal * DistributionLogNormal::clone() const override\n"
+ "DistributionLogNormal::clone\n"
""},
{ "DistributionLogNormal_className", _wrap_DistributionLogNormal_className, METH_O, "\n"
"DistributionLogNormal_className(DistributionLogNormal self) -> std::string\n"
"std::string DistributionLogNormal::className() const final\n"
- "\n"
+ "DistributionLogNormal::className\n"
"Returns the class name, to be hard-coded in each leaf class that inherits from INode. \n"
"\n"
""},
{ "DistributionLogNormal_parDefs", _wrap_DistributionLogNormal_parDefs, METH_O, "\n"
"DistributionLogNormal_parDefs(DistributionLogNormal self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >\n"
- "std::vector<ParaMeta> DistributionLogNormal::parDefs() const final\n"
- "\n"
+ "std::vector< ParaMeta > DistributionLogNormal::parDefs() const final\n"
+ "DistributionLogNormal::parDefs\n"
"Returns the parameter definitions, to be hard-coded in each leaf class. \n"
"\n"
""},
{ "DistributionLogNormal_probabilityDensity", _wrap_DistributionLogNormal_probabilityDensity, METH_VARARGS, "\n"
"DistributionLogNormal_probabilityDensity(DistributionLogNormal self, double x) -> double\n"
"double DistributionLogNormal::probabilityDensity(double x) const override\n"
- "\n"
+ "DistributionLogNormal::probabilityDensity\n"
"Returns the distribution-specific probability density for value x. \n"
"\n"
""},
{ "DistributionLogNormal_mean", _wrap_DistributionLogNormal_mean, METH_O, "\n"
"DistributionLogNormal_mean(DistributionLogNormal self) -> double\n"
"double DistributionLogNormal::mean() const override\n"
- "\n"
+ "DistributionLogNormal::mean\n"
"Returns the distribution-specific mean. \n"
"\n"
""},
{ "DistributionLogNormal_getMedian", _wrap_DistributionLogNormal_getMedian, METH_O, "\n"
"DistributionLogNormal_getMedian(DistributionLogNormal self) -> double\n"
"double DistributionLogNormal::getMedian() const\n"
- "\n"
+ "DistributionLogNormal::getMedian\n"
""},
{ "DistributionLogNormal_getScalePar", _wrap_DistributionLogNormal_getScalePar, METH_O, "\n"
"DistributionLogNormal_getScalePar(DistributionLogNormal self) -> double\n"
"double DistributionLogNormal::getScalePar() const\n"
- "\n"
+ "DistributionLogNormal::getScalePar\n"
""},
{ "DistributionLogNormal_equidistantPoints", _wrap_DistributionLogNormal_equidistantPoints, METH_VARARGS, "\n"
"DistributionLogNormal_equidistantPoints(DistributionLogNormal self, size_t nbr_samples, double sigma_factor, RealLimits const & limits={}) -> vdouble1d_t\n"
"std::vector< double > DistributionLogNormal::equidistantPoints(size_t nbr_samples, double sigma_factor, const RealLimits &limits={}) const override\n"
- "\n"
+ "DistributionLogNormal::equidistantPoints\n"
"generate list of sample values \n"
"\n"
""},
{ "DistributionLogNormal_isDelta", _wrap_DistributionLogNormal_isDelta, METH_O, "\n"
"DistributionLogNormal_isDelta(DistributionLogNormal self) -> bool\n"
"bool DistributionLogNormal::isDelta() const override\n"
- "\n"
+ "DistributionLogNormal::isDelta\n"
"Returns true if the distribution is in the limit case of a Dirac delta distribution. \n"
"\n"
""},
@@ -35146,57 +35146,57 @@ static PyMethodDef SwigMethods[] = {
"DistributionCosine(double mean, double sigma)\n"
"new_DistributionCosine() -> DistributionCosine\n"
"DistributionCosine::DistributionCosine()\n"
- "\n"
+ "DistributionCosine::DistributionCosine\n"
""},
{ "DistributionCosine_clone", _wrap_DistributionCosine_clone, METH_O, "\n"
"DistributionCosine_clone(DistributionCosine self) -> DistributionCosine\n"
- "DistributionCosine* DistributionCosine::clone() const override\n"
- "\n"
+ "DistributionCosine * DistributionCosine::clone() const override\n"
+ "DistributionCosine::clone\n"
""},
{ "DistributionCosine_className", _wrap_DistributionCosine_className, METH_O, "\n"
"DistributionCosine_className(DistributionCosine self) -> std::string\n"
"std::string DistributionCosine::className() const final\n"
- "\n"
+ "DistributionCosine::className\n"
"Returns the class name, to be hard-coded in each leaf class that inherits from INode. \n"
"\n"
""},
{ "DistributionCosine_parDefs", _wrap_DistributionCosine_parDefs, METH_O, "\n"
"DistributionCosine_parDefs(DistributionCosine self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >\n"
- "std::vector<ParaMeta> DistributionCosine::parDefs() const final\n"
- "\n"
+ "std::vector< ParaMeta > DistributionCosine::parDefs() const final\n"
+ "DistributionCosine::parDefs\n"
"Returns the parameter definitions, to be hard-coded in each leaf class. \n"
"\n"
""},
{ "DistributionCosine_probabilityDensity", _wrap_DistributionCosine_probabilityDensity, METH_VARARGS, "\n"
"DistributionCosine_probabilityDensity(DistributionCosine self, double x) -> double\n"
"double DistributionCosine::probabilityDensity(double x) const override\n"
- "\n"
+ "DistributionCosine::probabilityDensity\n"
"Returns the distribution-specific probability density for value x. \n"
"\n"
""},
{ "DistributionCosine_mean", _wrap_DistributionCosine_mean, METH_O, "\n"
"DistributionCosine_mean(DistributionCosine self) -> double\n"
"double DistributionCosine::mean() const override\n"
- "\n"
+ "DistributionCosine::mean\n"
"Returns the distribution-specific mean. \n"
"\n"
""},
{ "DistributionCosine_sigma", _wrap_DistributionCosine_sigma, METH_O, "\n"
"DistributionCosine_sigma(DistributionCosine self) -> double\n"
"double DistributionCosine::sigma() const\n"
- "\n"
+ "DistributionCosine::sigma\n"
""},
{ "DistributionCosine_equidistantPoints", _wrap_DistributionCosine_equidistantPoints, METH_VARARGS, "\n"
"DistributionCosine_equidistantPoints(DistributionCosine self, size_t nbr_samples, double sigma_factor, RealLimits const & limits={}) -> vdouble1d_t\n"
"std::vector< double > DistributionCosine::equidistantPoints(size_t nbr_samples, double sigma_factor, const RealLimits &limits={}) const override\n"
- "\n"
+ "DistributionCosine::equidistantPoints\n"
"generate list of sample values \n"
"\n"
""},
{ "DistributionCosine_isDelta", _wrap_DistributionCosine_isDelta, METH_O, "\n"
"DistributionCosine_isDelta(DistributionCosine self) -> bool\n"
"bool DistributionCosine::isDelta() const override\n"
- "\n"
+ "DistributionCosine::isDelta\n"
"Returns true if the distribution is in the limit case of a Dirac delta distribution. \n"
"\n"
""},
@@ -35208,67 +35208,67 @@ static PyMethodDef SwigMethods[] = {
"DistributionTrapezoid(double center, double left, double middle, double right)\n"
"new_DistributionTrapezoid() -> DistributionTrapezoid\n"
"DistributionTrapezoid::DistributionTrapezoid()\n"
- "\n"
+ "DistributionTrapezoid::DistributionTrapezoid\n"
""},
{ "DistributionTrapezoid_clone", _wrap_DistributionTrapezoid_clone, METH_O, "\n"
"DistributionTrapezoid_clone(DistributionTrapezoid self) -> DistributionTrapezoid\n"
- "DistributionTrapezoid* DistributionTrapezoid::clone() const override\n"
- "\n"
+ "DistributionTrapezoid * DistributionTrapezoid::clone() const override\n"
+ "DistributionTrapezoid::clone\n"
""},
{ "DistributionTrapezoid_className", _wrap_DistributionTrapezoid_className, METH_O, "\n"
"DistributionTrapezoid_className(DistributionTrapezoid self) -> std::string\n"
"std::string DistributionTrapezoid::className() const final\n"
- "\n"
+ "DistributionTrapezoid::className\n"
"Returns the class name, to be hard-coded in each leaf class that inherits from INode. \n"
"\n"
""},
{ "DistributionTrapezoid_parDefs", _wrap_DistributionTrapezoid_parDefs, METH_O, "\n"
"DistributionTrapezoid_parDefs(DistributionTrapezoid self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >\n"
- "std::vector<ParaMeta> DistributionTrapezoid::parDefs() const final\n"
- "\n"
+ "std::vector< ParaMeta > DistributionTrapezoid::parDefs() const final\n"
+ "DistributionTrapezoid::parDefs\n"
"Returns the parameter definitions, to be hard-coded in each leaf class. \n"
"\n"
""},
{ "DistributionTrapezoid_probabilityDensity", _wrap_DistributionTrapezoid_probabilityDensity, METH_VARARGS, "\n"
"DistributionTrapezoid_probabilityDensity(DistributionTrapezoid self, double x) -> double\n"
"double DistributionTrapezoid::probabilityDensity(double x) const override\n"
- "\n"
+ "DistributionTrapezoid::probabilityDensity\n"
"Returns the distribution-specific probability density for value x. \n"
"\n"
""},
{ "DistributionTrapezoid_mean", _wrap_DistributionTrapezoid_mean, METH_O, "\n"
"DistributionTrapezoid_mean(DistributionTrapezoid self) -> double\n"
"double DistributionTrapezoid::mean() const override\n"
- "\n"
+ "DistributionTrapezoid::mean\n"
"Returns the distribution-specific mean. \n"
"\n"
""},
{ "DistributionTrapezoid_getLeftWidth", _wrap_DistributionTrapezoid_getLeftWidth, METH_O, "\n"
"DistributionTrapezoid_getLeftWidth(DistributionTrapezoid self) -> double\n"
"double DistributionTrapezoid::getLeftWidth() const\n"
- "\n"
+ "DistributionTrapezoid::getLeftWidth\n"
""},
{ "DistributionTrapezoid_getMiddleWidth", _wrap_DistributionTrapezoid_getMiddleWidth, METH_O, "\n"
"DistributionTrapezoid_getMiddleWidth(DistributionTrapezoid self) -> double\n"
"double DistributionTrapezoid::getMiddleWidth() const\n"
- "\n"
+ "DistributionTrapezoid::getMiddleWidth\n"
""},
{ "DistributionTrapezoid_getRightWidth", _wrap_DistributionTrapezoid_getRightWidth, METH_O, "\n"
"DistributionTrapezoid_getRightWidth(DistributionTrapezoid self) -> double\n"
"double DistributionTrapezoid::getRightWidth() const\n"
- "\n"
+ "DistributionTrapezoid::getRightWidth\n"
""},
{ "DistributionTrapezoid_equidistantPoints", _wrap_DistributionTrapezoid_equidistantPoints, METH_VARARGS, "\n"
"DistributionTrapezoid_equidistantPoints(DistributionTrapezoid self, size_t nbr_samples, double sigma_factor, RealLimits const & limits={}) -> vdouble1d_t\n"
"std::vector< double > DistributionTrapezoid::equidistantPoints(size_t nbr_samples, double sigma_factor, const RealLimits &limits={}) const override\n"
- "\n"
+ "DistributionTrapezoid::equidistantPoints\n"
"generate list of sample values \n"
"\n"
""},
{ "DistributionTrapezoid_isDelta", _wrap_DistributionTrapezoid_isDelta, METH_O, "\n"
"DistributionTrapezoid_isDelta(DistributionTrapezoid self) -> bool\n"
"bool DistributionTrapezoid::isDelta() const override\n"
- "\n"
+ "DistributionTrapezoid::isDelta\n"
"Returns true if the distribution is in the limit case of a Dirac delta distribution. \n"
"\n"
""},
@@ -35280,34 +35280,34 @@ static PyMethodDef SwigMethods[] = {
"ParameterDistribution(ParameterDistribution::WhichParameter whichParameter, IDistribution1D distribution, size_t nbr_samples, double xmin, double xmax)\n"
"new_ParameterDistribution(ParameterDistribution other) -> ParameterDistribution\n"
"ParameterDistribution::ParameterDistribution(const ParameterDistribution &other)\n"
- "\n"
+ "ParameterDistribution::ParameterDistribution\n"
""},
{ "delete_ParameterDistribution", _wrap_delete_ParameterDistribution, METH_O, "\n"
"delete_ParameterDistribution(ParameterDistribution self)\n"
"ParameterDistribution::~ParameterDistribution()\n"
- "\n"
+ "ParameterDistribution::~ParameterDistribution\n"
""},
{ "ParameterDistribution_whichParameter", _wrap_ParameterDistribution_whichParameter, METH_O, "\n"
"ParameterDistribution_whichParameter(ParameterDistribution self) -> ParameterDistribution::WhichParameter\n"
"ParameterDistribution::WhichParameter ParameterDistribution::whichParameter() const\n"
- "\n"
+ "ParameterDistribution::whichParameter\n"
""},
{ "ParameterDistribution_whichParameterAsPyEnum", _wrap_ParameterDistribution_whichParameterAsPyEnum, METH_O, "\n"
"ParameterDistribution_whichParameterAsPyEnum(ParameterDistribution self) -> std::string\n"
"std::string ParameterDistribution::whichParameterAsPyEnum() const\n"
- "\n"
+ "ParameterDistribution::whichParameterAsPyEnum\n"
""},
{ "ParameterDistribution_nDraws", _wrap_ParameterDistribution_nDraws, METH_O, "\n"
"ParameterDistribution_nDraws(ParameterDistribution self) -> size_t\n"
"size_t ParameterDistribution::nDraws() const\n"
- "\n"
+ "ParameterDistribution::nDraws\n"
"get number of samples for this distribution \n"
"\n"
""},
{ "ParameterDistribution_sigmaFactor", _wrap_ParameterDistribution_sigmaFactor, METH_O, "\n"
"ParameterDistribution_sigmaFactor(ParameterDistribution self) -> double\n"
"double ParameterDistribution::sigmaFactor() const\n"
- "\n"
+ "ParameterDistribution::sigmaFactor\n"
"get the sigma factor \n"
"\n"
""},
@@ -35315,29 +35315,29 @@ static PyMethodDef SwigMethods[] = {
"ParameterDistribution_getDistribution(ParameterDistribution self) -> IDistribution1D\n"
"ParameterDistribution_getDistribution(ParameterDistribution self) -> IDistribution1D\n"
"IDistribution1D * ParameterDistribution::getDistribution()\n"
- "\n"
+ "ParameterDistribution::getDistribution\n"
""},
{ "ParameterDistribution_generateSamples", _wrap_ParameterDistribution_generateSamples, METH_O, "\n"
"ParameterDistribution_generateSamples(ParameterDistribution self) -> std::vector< ParameterSample,std::allocator< ParameterSample > >\n"
"std::vector< ParameterSample > ParameterDistribution::generateSamples() const\n"
- "\n"
+ "ParameterDistribution::generateSamples\n"
"generate list of sampled values with their weight \n"
"\n"
""},
{ "ParameterDistribution_getLimits", _wrap_ParameterDistribution_getLimits, METH_O, "\n"
"ParameterDistribution_getLimits(ParameterDistribution self) -> RealLimits\n"
"RealLimits ParameterDistribution::getLimits() const\n"
- "\n"
+ "ParameterDistribution::getLimits\n"
""},
{ "ParameterDistribution_getMinValue", _wrap_ParameterDistribution_getMinValue, METH_O, "\n"
"ParameterDistribution_getMinValue(ParameterDistribution self) -> double\n"
"double ParameterDistribution::getMinValue() const\n"
- "\n"
+ "ParameterDistribution::getMinValue\n"
""},
{ "ParameterDistribution_getMaxValue", _wrap_ParameterDistribution_getMaxValue, METH_O, "\n"
"ParameterDistribution_getMaxValue(ParameterDistribution self) -> double\n"
"double ParameterDistribution::getMaxValue() const\n"
- "\n"
+ "ParameterDistribution::getMaxValue\n"
""},
{ "ParameterDistribution_swigregister", ParameterDistribution_swigregister, METH_O, NULL},
{ "ParameterDistribution_swiginit", ParameterDistribution_swiginit, METH_VARARGS, NULL},
@@ -35346,24 +35346,24 @@ static PyMethodDef SwigMethods[] = {
"RangedDistributionGate(size_t n_samples, double sigma_factor, RealLimits const & limits=RealLimits::limitless())\n"
"new_RangedDistributionGate(size_t n_samples, double sigma_factor, double min, double max) -> RangedDistributionGate\n"
"RangedDistributionGate::RangedDistributionGate(size_t n_samples, double sigma_factor, double min, double max)\n"
- "\n"
+ "RangedDistributionGate::RangedDistributionGate\n"
"Initializes Ranged distribution with given number of samples, sigma factor (range in standard deviations to take into account during sample generation) and limits (either RealLimits object or just min and max limits). By default n_samples = 5, sigma_factor = 2.0, while the limits are (-inf, +inf). \n"
"\n"
""},
{ "RangedDistributionGate_clone", _wrap_RangedDistributionGate_clone, METH_O, "\n"
"RangedDistributionGate_clone(RangedDistributionGate self) -> RangedDistributionGate\n"
"RangedDistributionGate * RangedDistributionGate::clone() const override\n"
- "\n"
+ "RangedDistributionGate::clone\n"
""},
{ "delete_RangedDistributionGate", _wrap_delete_RangedDistributionGate, METH_O, "\n"
"delete_RangedDistributionGate(RangedDistributionGate self)\n"
"RangedDistributionGate::~RangedDistributionGate() override=default\n"
- "\n"
+ "RangedDistributionGate::~RangedDistributionGate\n"
""},
{ "RangedDistributionGate_name", _wrap_RangedDistributionGate_name, METH_O, "\n"
"RangedDistributionGate_name(RangedDistributionGate self) -> std::string\n"
"std::string RangedDistributionGate::name() const override\n"
- "\n"
+ "RangedDistributionGate::name\n"
"Returns distribution name for python-formatted text. \n"
"\n"
""},
@@ -35374,24 +35374,24 @@ static PyMethodDef SwigMethods[] = {
"RangedDistributionLorentz(size_t n_samples, double hwhm_factor, RealLimits const & limits=RealLimits::limitless())\n"
"new_RangedDistributionLorentz(size_t n_samples, double hwhm_factor, double min, double max) -> RangedDistributionLorentz\n"
"RangedDistributionLorentz::RangedDistributionLorentz(size_t n_samples, double hwhm_factor, double min, double max)\n"
- "\n"
+ "RangedDistributionLorentz::RangedDistributionLorentz\n"
"Initializes Ranged distribution with given number of samples, sigma factor (range in standard deviations to take into account during sample generation) and limits (either RealLimits object or just min and max limits). By default n_samples = 5, hwhm_factor = 2.0, while the limits are (-inf, +inf). \n"
"\n"
""},
{ "RangedDistributionLorentz_clone", _wrap_RangedDistributionLorentz_clone, METH_O, "\n"
"RangedDistributionLorentz_clone(RangedDistributionLorentz self) -> RangedDistributionLorentz\n"
"RangedDistributionLorentz * RangedDistributionLorentz::clone() const override\n"
- "\n"
+ "RangedDistributionLorentz::clone\n"
""},
{ "delete_RangedDistributionLorentz", _wrap_delete_RangedDistributionLorentz, METH_O, "\n"
"delete_RangedDistributionLorentz(RangedDistributionLorentz self)\n"
"RangedDistributionLorentz::~RangedDistributionLorentz() override=default\n"
- "\n"
+ "RangedDistributionLorentz::~RangedDistributionLorentz\n"
""},
{ "RangedDistributionLorentz_name", _wrap_RangedDistributionLorentz_name, METH_O, "\n"
"RangedDistributionLorentz_name(RangedDistributionLorentz self) -> std::string\n"
"std::string RangedDistributionLorentz::name() const override\n"
- "\n"
+ "RangedDistributionLorentz::name\n"
"Returns distribution name for python-formatted text. \n"
"\n"
""},
@@ -35402,24 +35402,24 @@ static PyMethodDef SwigMethods[] = {
"RangedDistributionGaussian(size_t n_samples, double sigma_factor, RealLimits const & limits=RealLimits::limitless())\n"
"new_RangedDistributionGaussian(size_t n_samples, double sigma_factor, double min, double max) -> RangedDistributionGaussian\n"
"RangedDistributionGaussian::RangedDistributionGaussian(size_t n_samples, double sigma_factor, double min, double max)\n"
- "\n"
+ "RangedDistributionGaussian::RangedDistributionGaussian\n"
"Initializes Ranged distribution with given number of samples, sigma factor (range in standard deviations to take into account during sample generation) and limits (either RealLimits object or just min and max limits). By default n_samples = 5, sigma_factor = 2.0, while the limits are (-inf, +inf). \n"
"\n"
""},
{ "RangedDistributionGaussian_clone", _wrap_RangedDistributionGaussian_clone, METH_O, "\n"
"RangedDistributionGaussian_clone(RangedDistributionGaussian self) -> RangedDistributionGaussian\n"
"RangedDistributionGaussian * RangedDistributionGaussian::clone() const override\n"
- "\n"
+ "RangedDistributionGaussian::clone\n"
""},
{ "delete_RangedDistributionGaussian", _wrap_delete_RangedDistributionGaussian, METH_O, "\n"
"delete_RangedDistributionGaussian(RangedDistributionGaussian self)\n"
"RangedDistributionGaussian::~RangedDistributionGaussian() override=default\n"
- "\n"
+ "RangedDistributionGaussian::~RangedDistributionGaussian\n"
""},
{ "RangedDistributionGaussian_name", _wrap_RangedDistributionGaussian_name, METH_O, "\n"
"RangedDistributionGaussian_name(RangedDistributionGaussian self) -> std::string\n"
"std::string RangedDistributionGaussian::name() const override\n"
- "\n"
+ "RangedDistributionGaussian::name\n"
"Returns distribution name for python-formatted text. \n"
"\n"
""},
@@ -35430,24 +35430,24 @@ static PyMethodDef SwigMethods[] = {
"RangedDistributionLogNormal(size_t n_samples, double sigma_factor, RealLimits const & limits=RealLimits::limitless())\n"
"new_RangedDistributionLogNormal(size_t n_samples, double sigma_factor, double min, double max) -> RangedDistributionLogNormal\n"
"RangedDistributionLogNormal::RangedDistributionLogNormal(size_t n_samples, double sigma_factor, double min, double max)\n"
- "\n"
+ "RangedDistributionLogNormal::RangedDistributionLogNormal\n"
"Initializes Ranged distribution with given number of samples, sigma factor (range in standard deviations to take into account during sample generation) and limits (either RealLimits object or just min and max limits). By default n_samples = 5, sigma_factor = 2.0, while the limits are (-inf, +inf). \n"
"\n"
""},
{ "RangedDistributionLogNormal_clone", _wrap_RangedDistributionLogNormal_clone, METH_O, "\n"
"RangedDistributionLogNormal_clone(RangedDistributionLogNormal self) -> RangedDistributionLogNormal\n"
"RangedDistributionLogNormal * RangedDistributionLogNormal::clone() const override\n"
- "\n"
+ "RangedDistributionLogNormal::clone\n"
""},
{ "delete_RangedDistributionLogNormal", _wrap_delete_RangedDistributionLogNormal, METH_O, "\n"
"delete_RangedDistributionLogNormal(RangedDistributionLogNormal self)\n"
"RangedDistributionLogNormal::~RangedDistributionLogNormal() override=default\n"
- "\n"
+ "RangedDistributionLogNormal::~RangedDistributionLogNormal\n"
""},
{ "RangedDistributionLogNormal_name", _wrap_RangedDistributionLogNormal_name, METH_O, "\n"
"RangedDistributionLogNormal_name(RangedDistributionLogNormal self) -> std::string\n"
"std::string RangedDistributionLogNormal::name() const override\n"
- "\n"
+ "RangedDistributionLogNormal::name\n"
"Returns distribution name for python-formatted text. \n"
"\n"
""},
@@ -35458,24 +35458,24 @@ static PyMethodDef SwigMethods[] = {
"RangedDistributionCosine(size_t n_samples, double sigma_factor, RealLimits const & limits=RealLimits::limitless())\n"
"new_RangedDistributionCosine(size_t n_samples, double sigma_factor, double min, double max) -> RangedDistributionCosine\n"
"RangedDistributionCosine::RangedDistributionCosine(size_t n_samples, double sigma_factor, double min, double max)\n"
- "\n"
+ "RangedDistributionCosine::RangedDistributionCosine\n"
"Initializes Ranged distribution with given number of samples, sigma factor (range in standard deviations to take into account during sample generation) and limits (either RealLimits object or just min and max limits). By default n_samples = 5, sigma_factor = 2.0, while the limits are (-inf, +inf). \n"
"\n"
""},
{ "RangedDistributionCosine_clone", _wrap_RangedDistributionCosine_clone, METH_O, "\n"
"RangedDistributionCosine_clone(RangedDistributionCosine self) -> RangedDistributionCosine\n"
"RangedDistributionCosine * RangedDistributionCosine::clone() const override\n"
- "\n"
+ "RangedDistributionCosine::clone\n"
""},
{ "delete_RangedDistributionCosine", _wrap_delete_RangedDistributionCosine, METH_O, "\n"
"delete_RangedDistributionCosine(RangedDistributionCosine self)\n"
"RangedDistributionCosine::~RangedDistributionCosine() override=default\n"
- "\n"
+ "RangedDistributionCosine::~RangedDistributionCosine\n"
""},
{ "RangedDistributionCosine_name", _wrap_RangedDistributionCosine_name, METH_O, "\n"
"RangedDistributionCosine_name(RangedDistributionCosine self) -> std::string\n"
"std::string RangedDistributionCosine::name() const override\n"
- "\n"
+ "RangedDistributionCosine::name\n"
"Returns distribution name for python-formatted text. \n"
"\n"
""},
@@ -35484,7 +35484,7 @@ static PyMethodDef SwigMethods[] = {
{ "new_ParameterSample", _wrap_new_ParameterSample, METH_VARARGS, "\n"
"ParameterSample(double _value, double _weight=1)\n"
"ParameterSample::ParameterSample(double _value, double _weight=1)\n"
- "\n"
+ "ParameterSample::ParameterSample\n"
""},
{ "ParameterSample_value_set", _wrap_ParameterSample_value_set, METH_VARARGS, "ParameterSample_value_set(ParameterSample self, double value)"},
{ "ParameterSample_value_get", _wrap_ParameterSample_value_get, METH_O, "ParameterSample_value_get(ParameterSample self) -> double"},
diff --git a/auto/Wrap/libBornAgainSample.py b/auto/Wrap/libBornAgainSample.py
index 2480456c8d8..51b61a301d0 100644
--- a/auto/Wrap/libBornAgainSample.py
+++ b/auto/Wrap/libBornAgainSample.py
@@ -7755,6 +7755,14 @@ class Box(IFormFactorPrism):
Box::formfactor_at_bottom
"""
return _libBornAgainSample.Box_formfactor_at_bottom(self, q)
+
+ def validate(self):
+ r"""
+ validate(Box self) -> std::string
+ std::string Box::validate() const final
+ Box::validate
+ """
+ return _libBornAgainSample.Box_validate(self)
__swig_destroy__ = _libBornAgainSample.delete_Box
# Register Box in _libBornAgainSample:
diff --git a/auto/Wrap/libBornAgainSample_wrap.cpp b/auto/Wrap/libBornAgainSample_wrap.cpp
index 7a10a383a0e..c0ebb510ea8 100644
--- a/auto/Wrap/libBornAgainSample_wrap.cpp
+++ b/auto/Wrap/libBornAgainSample_wrap.cpp
@@ -49434,6 +49434,29 @@ fail:
}
+SWIGINTERN PyObject *_wrap_Box_validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ Box *arg1 = (Box *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::string result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Box, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Box_validate" "', argument " "1"" of type '" "Box const *""'");
+ }
+ arg1 = reinterpret_cast< Box * >(argp1);
+ result = ((Box const *)arg1)->validate();
+ resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
SWIGINTERN PyObject *_wrap_delete_Box(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Box *arg1 = (Box *) 0 ;
@@ -64224,6 +64247,11 @@ static PyMethodDef SwigMethods[] = {
"complex_t Box::formfactor_at_bottom(C3 q) const override\n"
"Box::formfactor_at_bottom\n"
""},
+ { "Box_validate", _wrap_Box_validate, METH_O, "\n"
+ "Box_validate(Box self) -> std::string\n"
+ "std::string Box::validate() const final\n"
+ "Box::validate\n"
+ ""},
{ "delete_Box", _wrap_delete_Box, METH_O, "delete_Box(Box self)"},
{ "Box_swigregister", Box_swigregister, METH_O, NULL},
{ "Box_swiginit", Box_swiginit, METH_VARARGS, NULL},
--
GitLab