diff --git a/Core/Algorithms/inc/ISquaredFunction.h b/Core/Algorithms/inc/ISquaredFunction.h
index 8969ec38661b440e33e0254e8eb85d4efe1eca83..4c205fe255e9c3164e6c98f145819bfd1d508d17 100644
--- a/Core/Algorithms/inc/ISquaredFunction.h
+++ b/Core/Algorithms/inc/ISquaredFunction.h
@@ -31,19 +31,17 @@
class BA_CORE_API_ ISquaredFunction
{
public:
+ ISquaredFunction(){}
virtual ~ISquaredFunction() {}
virtual ISquaredFunction *clone() const=0;
-
virtual double calculateSquaredDifference(
double real_value, double simulated_value) const=0;
virtual double calculateSquaredError(
- double real_value, double simulated_value = 0.0) const
- { (void)real_value;
- (void)simulated_value;
- throw NotImplementedException(
- "ISquaredFunction::calculateError() -> "
- "Error! Not implemented.");
- }
+ double real_value, double simulated_value = 0.0) const = 0;
+
+private:
+ ISquaredFunction(const ISquaredFunction& );
+ ISquaredFunction& operator=(const ISquaredFunction& );
};
@@ -64,15 +62,14 @@ public:
virtual double calculateSquaredDifference(double real_value, double simulated_value) const
{
double diff_squared = (simulated_value-real_value)*(simulated_value-real_value);
- if (diff_squared < Numeric::double_epsilon) {
- return 0.0;
- }
- double sigma_squared = std::max(real_value,1.0);
- return diff_squared/sigma_squared;
+ if (diff_squared < Numeric::double_epsilon) return 0.0;
+ double normalization = calculateSquaredError(real_value);
+ return diff_squared/normalization;
}
- virtual double calculateSquaredError(double real_value, double /* simulated_value */) const
+ virtual double calculateSquaredError(double real_value, double simulated_value = 0) const
{
+ (void) simulated_value;
return std::max(real_value,1.0);
}
@@ -91,20 +88,24 @@ class BA_CORE_API_ SquaredFunctionMeanSquaredError : public ISquaredFunction
public:
SquaredFunctionMeanSquaredError() {}
virtual ~SquaredFunctionMeanSquaredError() {}
- virtual SquaredFunctionMeanSquaredError *clone() const { return new SquaredFunctionMeanSquaredError(*this); }
+ virtual SquaredFunctionMeanSquaredError *clone() const { return new SquaredFunctionMeanSquaredError(); }
virtual double calculateSquaredDifference(double real_value, double simulated_value) const
{
double diff_squared = (simulated_value-real_value)*(simulated_value-real_value);
- if (diff_squared < Numeric::double_epsilon) {
- return 0.0;
- }
+ if (diff_squared < Numeric::double_epsilon) return 0.0;
+ double normalization = calculateSquaredError(real_value, simulated_value);
+ return diff_squared/normalization;
+ }
+
+ virtual double calculateSquaredError(double real_value, double simulated_value) const
+ {
+ (void) simulated_value;
double sigma1 = std::max(real_value,1.0);
double sigma2 = std::max(simulated_value,1.0);
- double sigma = std::sqrt(sigma1*sigma1 + sigma2*sigma2);
- double normalization = sigma;
- return diff_squared/normalization;
+ return std::sqrt(sigma1*sigma1 + sigma2*sigma2);
}
+
};
@@ -120,14 +121,15 @@ class BA_CORE_API_ SquaredFunctionSystematicError : public ISquaredFunction
public:
SquaredFunctionSystematicError(double epsilon = 0.08) : m_epsilon(epsilon){}
virtual ~SquaredFunctionSystematicError() {}
- virtual SquaredFunctionSystematicError *clone() const { return new SquaredFunctionSystematicError(*this); }
+ virtual SquaredFunctionSystematicError *clone() const { return new SquaredFunctionSystematicError(m_epsilon); }
virtual double calculateSquaredDifference(double real_value, double simulated_value) const
{
double diff_squared = (simulated_value-real_value)*(simulated_value-real_value);
- return diff_squared/calculateSquaredError(real_value);
+ double normalization = calculateSquaredError(real_value, simulated_value);
+ return diff_squared/normalization;
}
- virtual double calculateSquaredError(double real_value, double simulated_value = 0.0) const
+ virtual double calculateSquaredError(double real_value, double simulated_value) const
{
(void)simulated_value;
return std::max(std::fabs(real_value) + (m_epsilon*real_value)*(m_epsilon*real_value),1.0);
@@ -150,7 +152,7 @@ class BA_CORE_API_ SquaredFunctionGaussianError : public ISquaredFunction
public:
SquaredFunctionGaussianError(double sigma = 0.01) : m_sigma(sigma){}
virtual ~SquaredFunctionGaussianError() {}
- virtual SquaredFunctionGaussianError *clone() const { return new SquaredFunctionGaussianError(*this); }
+ virtual SquaredFunctionGaussianError *clone() const { return new SquaredFunctionGaussianError(m_sigma); }
virtual double calculateSquaredDifference(double real_value, double simulated_value) const
{
diff --git a/Fit/PythonAPI/src/FitStrategyFixParameters.pypp.cpp b/Fit/PythonAPI/src/FitStrategyFixParameters.pypp.cpp
index 54738ca49f0a9600a42a14f88912e3057f961420..886c16916782f580310524a783cc4f10d3442aa8 100644
--- a/Fit/PythonAPI/src/FitStrategyFixParameters.pypp.cpp
+++ b/Fit/PythonAPI/src/FitStrategyFixParameters.pypp.cpp
@@ -30,6 +30,13 @@ struct FitStrategyFixParameters_wrapper : FitStrategyFixParameters, bp::wrapper<
}
+ FitStrategyFixParameters_wrapper(::std::vector< std::string > const & pars )
+ : FitStrategyFixParameters( boost::ref(pars) )
+ , bp::wrapper< FitStrategyFixParameters >(){
+ // constructor
+
+ }
+
virtual void clear( ) {
if( bp::override func_clear = this->get_override( "clear" ) )
func_clear( );
@@ -98,6 +105,7 @@ void register_FitStrategyFixParameters_class(){
typedef bp::class_< FitStrategyFixParameters_wrapper, bp::bases< FitStrategyAdjustParameters > > FitStrategyFixParameters_exposer_t;
FitStrategyFixParameters_exposer_t FitStrategyFixParameters_exposer = FitStrategyFixParameters_exposer_t( "FitStrategyFixParameters", bp::init< >() );
bp::scope FitStrategyFixParameters_scope( FitStrategyFixParameters_exposer );
+ FitStrategyFixParameters_exposer.def( bp::init< std::vector< std::string > const & >(( bp::arg("pars") )) );
{ //::FitStrategyFixParameters::clear
typedef void ( ::FitStrategyFixParameters::*clear_function_type )( ) ;
diff --git a/Fit/PythonAPI/src/FitStrategyReleaseParameters.pypp.cpp b/Fit/PythonAPI/src/FitStrategyReleaseParameters.pypp.cpp
index 4a41384a5627f02f13f708ea3411bf53411df533..b97d4a684760c96bacf526a96aa248b23c74e9b5 100644
--- a/Fit/PythonAPI/src/FitStrategyReleaseParameters.pypp.cpp
+++ b/Fit/PythonAPI/src/FitStrategyReleaseParameters.pypp.cpp
@@ -30,6 +30,13 @@ struct FitStrategyReleaseParameters_wrapper : FitStrategyReleaseParameters, bp::
}
+ FitStrategyReleaseParameters_wrapper(::std::vector< std::string > const & pars )
+ : FitStrategyReleaseParameters( boost::ref(pars) )
+ , bp::wrapper< FitStrategyReleaseParameters >(){
+ // constructor
+
+ }
+
virtual void clear( ) {
if( bp::override func_clear = this->get_override( "clear" ) )
func_clear( );
@@ -98,6 +105,7 @@ void register_FitStrategyReleaseParameters_class(){
typedef bp::class_< FitStrategyReleaseParameters_wrapper, bp::bases< FitStrategyAdjustParameters > > FitStrategyReleaseParameters_exposer_t;
FitStrategyReleaseParameters_exposer_t FitStrategyReleaseParameters_exposer = FitStrategyReleaseParameters_exposer_t( "FitStrategyReleaseParameters", bp::init< >() );
bp::scope FitStrategyReleaseParameters_scope( FitStrategyReleaseParameters_exposer );
+ FitStrategyReleaseParameters_exposer.def( bp::init< std::vector< std::string > const & >(( bp::arg("pars") )) );
{ //::FitStrategyReleaseParameters::clear
typedef void ( ::FitStrategyReleaseParameters::*clear_function_type )( ) ;
diff --git a/Fit/PythonAPI/src/ISquaredFunction.pypp.cpp b/Fit/PythonAPI/src/ISquaredFunction.pypp.cpp
index 03961fd42f54edf9f09a3ad4ce233f78b6345e0e..e8164d591c82ec0504b6751965f00e642c486677 100644
--- a/Fit/PythonAPI/src/ISquaredFunction.pypp.cpp
+++ b/Fit/PythonAPI/src/ISquaredFunction.pypp.cpp
@@ -16,11 +16,11 @@ namespace bp = boost::python;
struct ISquaredFunction_wrapper : ISquaredFunction, bp::wrapper< ISquaredFunction > {
- ISquaredFunction_wrapper()
- : ISquaredFunction()
+ ISquaredFunction_wrapper( )
+ : ISquaredFunction( )
, bp::wrapper< ISquaredFunction >(){
// null constructor
-
+
}
virtual double calculateSquaredDifference( double real_value, double simulated_value ) const {
@@ -28,16 +28,9 @@ struct ISquaredFunction_wrapper : ISquaredFunction, bp::wrapper< ISquaredFunctio
return func_calculateSquaredDifference( real_value, simulated_value );
}
- virtual double calculateSquaredError( double real_value, double simulated_value=0.0 ) const {
- if( bp::override func_calculateSquaredError = this->get_override( "calculateSquaredError" ) )
- return func_calculateSquaredError( real_value, simulated_value );
- else
- return this->ISquaredFunction::calculateSquaredError( real_value, simulated_value );
- }
-
-
- double default_calculateSquaredError( double real_value, double simulated_value=0.0 ) const {
- return ISquaredFunction::calculateSquaredError( real_value, simulated_value );
+ virtual double calculateSquaredError( double real_value, double simulated_value=0.0 ) const {
+ bp::override func_calculateSquaredError = this->get_override( "calculateSquaredError" );
+ return func_calculateSquaredError( real_value, simulated_value );
}
virtual ::ISquaredFunction * clone( ) const {
@@ -51,7 +44,7 @@ void register_ISquaredFunction_class(){
{ //::ISquaredFunction
typedef bp::class_< ISquaredFunction_wrapper, boost::noncopyable > ISquaredFunction_exposer_t;
- ISquaredFunction_exposer_t ISquaredFunction_exposer = ISquaredFunction_exposer_t( "ISquaredFunction" );
+ ISquaredFunction_exposer_t ISquaredFunction_exposer = ISquaredFunction_exposer_t( "ISquaredFunction", bp::init< >() );
bp::scope ISquaredFunction_scope( ISquaredFunction_exposer );
{ //::ISquaredFunction::calculateSquaredDifference
@@ -66,12 +59,10 @@ void register_ISquaredFunction_class(){
{ //::ISquaredFunction::calculateSquaredError
typedef double ( ::ISquaredFunction::*calculateSquaredError_function_type )( double,double ) const;
- typedef double ( ISquaredFunction_wrapper::*default_calculateSquaredError_function_type )( double,double ) const;
ISquaredFunction_exposer.def(
"calculateSquaredError"
- , calculateSquaredError_function_type(&::ISquaredFunction::calculateSquaredError)
- , default_calculateSquaredError_function_type(&ISquaredFunction_wrapper::default_calculateSquaredError)
+ , bp::pure_virtual( calculateSquaredError_function_type(&::ISquaredFunction::calculateSquaredError) )
, ( bp::arg("real_value"), bp::arg("simulated_value")=0.0 ) );
}
diff --git a/Fit/PythonAPI/src/SquaredFunctionDefault.pypp.cpp b/Fit/PythonAPI/src/SquaredFunctionDefault.pypp.cpp
index 3b0b52c824aaccf828d36061a7c0a4ba77a587a3..9b4d17d693fa41be165354c85ac9b0f22d73eebb 100644
--- a/Fit/PythonAPI/src/SquaredFunctionDefault.pypp.cpp
+++ b/Fit/PythonAPI/src/SquaredFunctionDefault.pypp.cpp
@@ -16,13 +16,6 @@ namespace bp = boost::python;
struct SquaredFunctionDefault_wrapper : SquaredFunctionDefault, bp::wrapper< SquaredFunctionDefault > {
- SquaredFunctionDefault_wrapper(SquaredFunctionDefault const & arg )
- : SquaredFunctionDefault( arg )
- , bp::wrapper< SquaredFunctionDefault >(){
- // copy constructor
-
- }
-
SquaredFunctionDefault_wrapper( )
: SquaredFunctionDefault( )
, bp::wrapper< SquaredFunctionDefault >(){
@@ -42,16 +35,16 @@ struct SquaredFunctionDefault_wrapper : SquaredFunctionDefault, bp::wrapper< Squ
return SquaredFunctionDefault::calculateSquaredDifference( real_value, simulated_value );
}
- virtual double calculateSquaredError( double real_value, double arg1 ) const {
+ virtual double calculateSquaredError( double real_value, double simulated_value=0 ) const {
if( bp::override func_calculateSquaredError = this->get_override( "calculateSquaredError" ) )
- return func_calculateSquaredError( real_value, arg1 );
+ return func_calculateSquaredError( real_value, simulated_value );
else
- return this->SquaredFunctionDefault::calculateSquaredError( real_value, arg1 );
+ return this->SquaredFunctionDefault::calculateSquaredError( real_value, simulated_value );
}
- double default_calculateSquaredError( double real_value, double arg1 ) const {
- return SquaredFunctionDefault::calculateSquaredError( real_value, arg1 );
+ double default_calculateSquaredError( double real_value, double simulated_value=0 ) const {
+ return SquaredFunctionDefault::calculateSquaredError( real_value, simulated_value );
}
virtual ::SquaredFunctionDefault * clone( ) const {
@@ -71,7 +64,7 @@ struct SquaredFunctionDefault_wrapper : SquaredFunctionDefault, bp::wrapper< Squ
void register_SquaredFunctionDefault_class(){
{ //::SquaredFunctionDefault
- typedef bp::class_< SquaredFunctionDefault_wrapper, bp::bases< ISquaredFunction > > SquaredFunctionDefault_exposer_t;
+ typedef bp::class_< SquaredFunctionDefault_wrapper, bp::bases< ISquaredFunction >, boost::noncopyable > SquaredFunctionDefault_exposer_t;
SquaredFunctionDefault_exposer_t SquaredFunctionDefault_exposer = SquaredFunctionDefault_exposer_t( "SquaredFunctionDefault", bp::init< >() );
bp::scope SquaredFunctionDefault_scope( SquaredFunctionDefault_exposer );
{ //::SquaredFunctionDefault::calculateSquaredDifference
@@ -95,7 +88,7 @@ void register_SquaredFunctionDefault_class(){
"calculateSquaredError"
, calculateSquaredError_function_type(&::SquaredFunctionDefault::calculateSquaredError)
, default_calculateSquaredError_function_type(&SquaredFunctionDefault_wrapper::default_calculateSquaredError)
- , ( bp::arg("real_value"), bp::arg("arg1") ) );
+ , ( bp::arg("real_value"), bp::arg("simulated_value")=0 ) );
}
{ //::SquaredFunctionDefault::clone
diff --git a/Fit/PythonAPI/src/SquaredFunctionGaussianError.pypp.cpp b/Fit/PythonAPI/src/SquaredFunctionGaussianError.pypp.cpp
index 35ffa1942c4cf3afdda57c4e380e82b111d1a58f..532433e882e432cb1af5bc41ac0aa60d5476c2a4 100644
--- a/Fit/PythonAPI/src/SquaredFunctionGaussianError.pypp.cpp
+++ b/Fit/PythonAPI/src/SquaredFunctionGaussianError.pypp.cpp
@@ -16,13 +16,6 @@ namespace bp = boost::python;
struct SquaredFunctionGaussianError_wrapper : SquaredFunctionGaussianError, bp::wrapper< SquaredFunctionGaussianError > {
- SquaredFunctionGaussianError_wrapper(SquaredFunctionGaussianError const & arg )
- : SquaredFunctionGaussianError( arg )
- , bp::wrapper< SquaredFunctionGaussianError >(){
- // copy constructor
-
- }
-
SquaredFunctionGaussianError_wrapper(double sigma=1.00000000000000002081668171172168513294309377670288085938e-2 )
: SquaredFunctionGaussianError( sigma )
, bp::wrapper< SquaredFunctionGaussianError >(){
@@ -71,7 +64,7 @@ struct SquaredFunctionGaussianError_wrapper : SquaredFunctionGaussianError, bp::
void register_SquaredFunctionGaussianError_class(){
{ //::SquaredFunctionGaussianError
- typedef bp::class_< SquaredFunctionGaussianError_wrapper, bp::bases< ISquaredFunction > > SquaredFunctionGaussianError_exposer_t;
+ typedef bp::class_< SquaredFunctionGaussianError_wrapper, bp::bases< ISquaredFunction >, boost::noncopyable > SquaredFunctionGaussianError_exposer_t;
SquaredFunctionGaussianError_exposer_t SquaredFunctionGaussianError_exposer = SquaredFunctionGaussianError_exposer_t( "SquaredFunctionGaussianError", bp::init< bp::optional< double > >(( bp::arg("sigma")=1.00000000000000002081668171172168513294309377670288085938e-2 )) );
bp::scope SquaredFunctionGaussianError_scope( SquaredFunctionGaussianError_exposer );
{ //::SquaredFunctionGaussianError::calculateSquaredDifference
diff --git a/Fit/PythonAPI/src/SquaredFunctionMeanSquaredError.pypp.cpp b/Fit/PythonAPI/src/SquaredFunctionMeanSquaredError.pypp.cpp
index 075705d2b2e4d0c3b26544f44f8d88e46a602afa..39872437b176f59bc5e684936fc89b856e26b368 100644
--- a/Fit/PythonAPI/src/SquaredFunctionMeanSquaredError.pypp.cpp
+++ b/Fit/PythonAPI/src/SquaredFunctionMeanSquaredError.pypp.cpp
@@ -16,13 +16,6 @@ namespace bp = boost::python;
struct SquaredFunctionMeanSquaredError_wrapper : SquaredFunctionMeanSquaredError, bp::wrapper< SquaredFunctionMeanSquaredError > {
- SquaredFunctionMeanSquaredError_wrapper(SquaredFunctionMeanSquaredError const & arg )
- : SquaredFunctionMeanSquaredError( arg )
- , bp::wrapper< SquaredFunctionMeanSquaredError >(){
- // copy constructor
-
- }
-
SquaredFunctionMeanSquaredError_wrapper( )
: SquaredFunctionMeanSquaredError( )
, bp::wrapper< SquaredFunctionMeanSquaredError >(){
@@ -42,28 +35,28 @@ struct SquaredFunctionMeanSquaredError_wrapper : SquaredFunctionMeanSquaredError
return SquaredFunctionMeanSquaredError::calculateSquaredDifference( real_value, simulated_value );
}
- virtual ::SquaredFunctionMeanSquaredError * clone( ) const {
- if( bp::override func_clone = this->get_override( "clone" ) )
- return func_clone( );
+ virtual double calculateSquaredError( double real_value, double simulated_value ) const {
+ if( bp::override func_calculateSquaredError = this->get_override( "calculateSquaredError" ) )
+ return func_calculateSquaredError( real_value, simulated_value );
else
- return this->SquaredFunctionMeanSquaredError::clone( );
+ return this->SquaredFunctionMeanSquaredError::calculateSquaredError( real_value, simulated_value );
}
- ::SquaredFunctionMeanSquaredError * default_clone( ) const {
- return SquaredFunctionMeanSquaredError::clone( );
+ double default_calculateSquaredError( double real_value, double simulated_value ) const {
+ return SquaredFunctionMeanSquaredError::calculateSquaredError( real_value, simulated_value );
}
- virtual double calculateSquaredError( double real_value, double simulated_value=0.0 ) const {
- if( bp::override func_calculateSquaredError = this->get_override( "calculateSquaredError" ) )
- return func_calculateSquaredError( real_value, simulated_value );
+ virtual ::SquaredFunctionMeanSquaredError * clone( ) const {
+ if( bp::override func_clone = this->get_override( "clone" ) )
+ return func_clone( );
else
- return this->ISquaredFunction::calculateSquaredError( real_value, simulated_value );
+ return this->SquaredFunctionMeanSquaredError::clone( );
}
- double default_calculateSquaredError( double real_value, double simulated_value=0.0 ) const {
- return ISquaredFunction::calculateSquaredError( real_value, simulated_value );
+ ::SquaredFunctionMeanSquaredError * default_clone( ) const {
+ return SquaredFunctionMeanSquaredError::clone( );
}
};
@@ -71,7 +64,7 @@ struct SquaredFunctionMeanSquaredError_wrapper : SquaredFunctionMeanSquaredError
void register_SquaredFunctionMeanSquaredError_class(){
{ //::SquaredFunctionMeanSquaredError
- typedef bp::class_< SquaredFunctionMeanSquaredError_wrapper, bp::bases< ISquaredFunction > > SquaredFunctionMeanSquaredError_exposer_t;
+ typedef bp::class_< SquaredFunctionMeanSquaredError_wrapper, bp::bases< ISquaredFunction >, boost::noncopyable > SquaredFunctionMeanSquaredError_exposer_t;
SquaredFunctionMeanSquaredError_exposer_t SquaredFunctionMeanSquaredError_exposer = SquaredFunctionMeanSquaredError_exposer_t( "SquaredFunctionMeanSquaredError", bp::init< >() );
bp::scope SquaredFunctionMeanSquaredError_scope( SquaredFunctionMeanSquaredError_exposer );
{ //::SquaredFunctionMeanSquaredError::calculateSquaredDifference
@@ -85,6 +78,18 @@ void register_SquaredFunctionMeanSquaredError_class(){
, default_calculateSquaredDifference_function_type(&SquaredFunctionMeanSquaredError_wrapper::default_calculateSquaredDifference)
, ( bp::arg("real_value"), bp::arg("simulated_value") ) );
+ }
+ { //::SquaredFunctionMeanSquaredError::calculateSquaredError
+
+ typedef double ( ::SquaredFunctionMeanSquaredError::*calculateSquaredError_function_type )( double,double ) const;
+ typedef double ( SquaredFunctionMeanSquaredError_wrapper::*default_calculateSquaredError_function_type )( double,double ) const;
+
+ SquaredFunctionMeanSquaredError_exposer.def(
+ "calculateSquaredError"
+ , calculateSquaredError_function_type(&::SquaredFunctionMeanSquaredError::calculateSquaredError)
+ , default_calculateSquaredError_function_type(&SquaredFunctionMeanSquaredError_wrapper::default_calculateSquaredError)
+ , ( bp::arg("real_value"), bp::arg("simulated_value") ) );
+
}
{ //::SquaredFunctionMeanSquaredError::clone
@@ -98,18 +103,6 @@ void register_SquaredFunctionMeanSquaredError_class(){
, bp::return_value_policy< bp::manage_new_object >() );
}
- { //::ISquaredFunction::calculateSquaredError
-
- typedef double ( ::ISquaredFunction::*calculateSquaredError_function_type )( double,double ) const;
- typedef double ( SquaredFunctionMeanSquaredError_wrapper::*default_calculateSquaredError_function_type )( double,double ) const;
-
- SquaredFunctionMeanSquaredError_exposer.def(
- "calculateSquaredError"
- , calculateSquaredError_function_type(&::ISquaredFunction::calculateSquaredError)
- , default_calculateSquaredError_function_type(&SquaredFunctionMeanSquaredError_wrapper::default_calculateSquaredError)
- , ( bp::arg("real_value"), bp::arg("simulated_value")=0.0 ) );
-
- }
}
}
diff --git a/Fit/PythonAPI/src/SquaredFunctionSystematicError.pypp.cpp b/Fit/PythonAPI/src/SquaredFunctionSystematicError.pypp.cpp
index f6db460c160a45c94d6bf50a7a6edc7a310d08fb..3c321f1af1aeaebc187a7c4fbe426bfe6798147a 100644
--- a/Fit/PythonAPI/src/SquaredFunctionSystematicError.pypp.cpp
+++ b/Fit/PythonAPI/src/SquaredFunctionSystematicError.pypp.cpp
@@ -16,13 +16,6 @@ namespace bp = boost::python;
struct SquaredFunctionSystematicError_wrapper : SquaredFunctionSystematicError, bp::wrapper< SquaredFunctionSystematicError > {
- SquaredFunctionSystematicError_wrapper(SquaredFunctionSystematicError const & arg )
- : SquaredFunctionSystematicError( arg )
- , bp::wrapper< SquaredFunctionSystematicError >(){
- // copy constructor
-
- }
-
SquaredFunctionSystematicError_wrapper(double epsilon=8.000000000000000166533453693773481063544750213623046875e-2 )
: SquaredFunctionSystematicError( epsilon )
, bp::wrapper< SquaredFunctionSystematicError >(){
@@ -42,7 +35,7 @@ struct SquaredFunctionSystematicError_wrapper : SquaredFunctionSystematicError,
return SquaredFunctionSystematicError::calculateSquaredDifference( real_value, simulated_value );
}
- virtual double calculateSquaredError( double real_value, double simulated_value=0.0 ) const {
+ virtual double calculateSquaredError( double real_value, double simulated_value ) const {
if( bp::override func_calculateSquaredError = this->get_override( "calculateSquaredError" ) )
return func_calculateSquaredError( real_value, simulated_value );
else
@@ -50,7 +43,7 @@ struct SquaredFunctionSystematicError_wrapper : SquaredFunctionSystematicError,
}
- double default_calculateSquaredError( double real_value, double simulated_value=0.0 ) const {
+ double default_calculateSquaredError( double real_value, double simulated_value ) const {
return SquaredFunctionSystematicError::calculateSquaredError( real_value, simulated_value );
}
@@ -71,7 +64,7 @@ struct SquaredFunctionSystematicError_wrapper : SquaredFunctionSystematicError,
void register_SquaredFunctionSystematicError_class(){
{ //::SquaredFunctionSystematicError
- typedef bp::class_< SquaredFunctionSystematicError_wrapper, bp::bases< ISquaredFunction > > SquaredFunctionSystematicError_exposer_t;
+ typedef bp::class_< SquaredFunctionSystematicError_wrapper, bp::bases< ISquaredFunction >, boost::noncopyable > SquaredFunctionSystematicError_exposer_t;
SquaredFunctionSystematicError_exposer_t SquaredFunctionSystematicError_exposer = SquaredFunctionSystematicError_exposer_t( "SquaredFunctionSystematicError", bp::init< bp::optional< double > >(( bp::arg("epsilon")=8.000000000000000166533453693773481063544750213623046875e-2 )) );
bp::scope SquaredFunctionSystematicError_scope( SquaredFunctionSystematicError_exposer );
{ //::SquaredFunctionSystematicError::calculateSquaredDifference
@@ -95,7 +88,7 @@ void register_SquaredFunctionSystematicError_class(){
"calculateSquaredError"
, calculateSquaredError_function_type(&::SquaredFunctionSystematicError::calculateSquaredError)
, default_calculateSquaredError_function_type(&SquaredFunctionSystematicError_wrapper::default_calculateSquaredError)
- , ( bp::arg("real_value"), bp::arg("simulated_value")=0.0 ) );
+ , ( bp::arg("real_value"), bp::arg("simulated_value") ) );
}
{ //::SquaredFunctionSystematicError::clone