void register_NullAccumulator_class(){
{ //::SireMaths::NullAccumulator
typedef bp::class_< SireMaths::NullAccumulator, bp::bases< SireMaths::Accumulator, SireBase::Property > > NullAccumulator_exposer_t;
NullAccumulator_exposer_t NullAccumulator_exposer = NullAccumulator_exposer_t( "NullAccumulator", bp::init< >() );
bp::scope NullAccumulator_scope( NullAccumulator_exposer );
NullAccumulator_exposer.def( bp::init< SireMaths::NullAccumulator const & >(( bp::arg("other") )) );
{ //::SireMaths::NullAccumulator::accumulate
typedef void ( ::SireMaths::NullAccumulator::*accumulate_function_type )( double ) ;
accumulate_function_type accumulate_function_value( &::SireMaths::NullAccumulator::accumulate );
NullAccumulator_exposer.def(
"accumulate"
, accumulate_function_value
, ( bp::arg("value") ) );
}
NullAccumulator_exposer.def( bp::self != bp::self );
{ //::SireMaths::NullAccumulator::operator=
typedef ::SireMaths::NullAccumulator & ( ::SireMaths::NullAccumulator::*assign_function_type )( ::SireMaths::NullAccumulator const & ) ;
assign_function_type assign_function_value( &::SireMaths::NullAccumulator::operator= );
NullAccumulator_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
NullAccumulator_exposer.def( bp::self == bp::self );
{ //::SireMaths::NullAccumulator::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMaths::NullAccumulator::typeName );
NullAccumulator_exposer.def(
"typeName"
, typeName_function_value );
}
NullAccumulator_exposer.staticmethod( "typeName" );
NullAccumulator_exposer.def( "__copy__", &__copy__);
NullAccumulator_exposer.def( "__deepcopy__", &__copy__);
NullAccumulator_exposer.def( "clone", &__copy__);
NullAccumulator_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMaths::NullAccumulator >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
NullAccumulator_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMaths::NullAccumulator >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
NullAccumulator_exposer.def( "__str__", &__str__< ::SireMaths::NullAccumulator > );
NullAccumulator_exposer.def( "__repr__", &__str__< ::SireMaths::NullAccumulator > );
}
}
void register_AverageAndStddev_class(){
{ //::SireMaths::AverageAndStddev
typedef bp::class_< SireMaths::AverageAndStddev, bp::bases< SireMaths::Average, SireMaths::Accumulator, SireBase::Property > > AverageAndStddev_exposer_t;
AverageAndStddev_exposer_t AverageAndStddev_exposer = AverageAndStddev_exposer_t( "AverageAndStddev", bp::init< >() );
bp::scope AverageAndStddev_scope( AverageAndStddev_exposer );
AverageAndStddev_exposer.def( bp::init< SireMaths::AverageAndStddev const & >(( bp::arg("other") )) );
{ //::SireMaths::AverageAndStddev::accumulate
typedef void ( ::SireMaths::AverageAndStddev::*accumulate_function_type )( double ) ;
accumulate_function_type accumulate_function_value( &::SireMaths::AverageAndStddev::accumulate );
AverageAndStddev_exposer.def(
"accumulate"
, accumulate_function_value
, ( bp::arg("value") ) );
}
{ //::SireMaths::AverageAndStddev::clear
typedef void ( ::SireMaths::AverageAndStddev::*clear_function_type )( ) ;
clear_function_type clear_function_value( &::SireMaths::AverageAndStddev::clear );
AverageAndStddev_exposer.def(
"clear"
, clear_function_value );
}
{ //::SireMaths::AverageAndStddev::meanOfSquares
typedef double ( ::SireMaths::AverageAndStddev::*meanOfSquares_function_type )( ) const;
meanOfSquares_function_type meanOfSquares_function_value( &::SireMaths::AverageAndStddev::meanOfSquares );
AverageAndStddev_exposer.def(
"meanOfSquares"
, meanOfSquares_function_value );
}
AverageAndStddev_exposer.def( bp::self != bp::self );
AverageAndStddev_exposer.def( bp::self + bp::self );
{ //::SireMaths::AverageAndStddev::operator=
typedef ::SireMaths::AverageAndStddev & ( ::SireMaths::AverageAndStddev::*assign_function_type )( ::SireMaths::AverageAndStddev const & ) ;
assign_function_type assign_function_value( &::SireMaths::AverageAndStddev::operator= );
AverageAndStddev_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
AverageAndStddev_exposer.def( bp::self == bp::self );
{ //::SireMaths::AverageAndStddev::standardDeviation
typedef double ( ::SireMaths::AverageAndStddev::*standardDeviation_function_type )( ) const;
standardDeviation_function_type standardDeviation_function_value( &::SireMaths::AverageAndStddev::standardDeviation );
AverageAndStddev_exposer.def(
"standardDeviation"
, standardDeviation_function_value );
}
{ //::SireMaths::AverageAndStddev::standardError
typedef double ( ::SireMaths::AverageAndStddev::*standardError_function_type )( ) const;
standardError_function_type standardError_function_value( &::SireMaths::AverageAndStddev::standardError );
AverageAndStddev_exposer.def(
"standardError"
, standardError_function_value );
}
{ //::SireMaths::AverageAndStddev::standardError
typedef double ( ::SireMaths::AverageAndStddev::*standardError_function_type )( int ) const;
standardError_function_type standardError_function_value( &::SireMaths::AverageAndStddev::standardError );
AverageAndStddev_exposer.def(
"standardError"
, standardError_function_value
, ( bp::arg("level") ) );
}
{ //::SireMaths::AverageAndStddev::stddev
typedef double ( ::SireMaths::AverageAndStddev::*stddev_function_type )( ) const;
stddev_function_type stddev_function_value( &::SireMaths::AverageAndStddev::stddev );
AverageAndStddev_exposer.def(
"stddev"
, stddev_function_value );
}
{ //::SireMaths::AverageAndStddev::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMaths::AverageAndStddev::typeName );
AverageAndStddev_exposer.def(
"typeName"
, typeName_function_value );
}
AverageAndStddev_exposer.staticmethod( "typeName" );
AverageAndStddev_exposer.def( "__copy__", &__copy__);
AverageAndStddev_exposer.def( "__deepcopy__", &__copy__);
AverageAndStddev_exposer.def( "clone", &__copy__);
AverageAndStddev_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMaths::AverageAndStddev >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
AverageAndStddev_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMaths::AverageAndStddev >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
AverageAndStddev_exposer.def( "__str__", &__str__< ::SireMaths::AverageAndStddev > );
AverageAndStddev_exposer.def( "__repr__", &__str__< ::SireMaths::AverageAndStddev > );
}
}
void register_Median_class(){
{ //::SireMaths::Median
typedef bp::class_< SireMaths::Median, bp::bases< SireMaths::Accumulator, SireBase::Property > > Median_exposer_t;
Median_exposer_t Median_exposer = Median_exposer_t( "Median", "This class is used to calculate the maximum, minimum and median\nof a collection of values\n\nAuthor: Christopher Woods\n", bp::init< >("Construct an empty average") );
bp::scope Median_scope( Median_exposer );
Median_exposer.def( bp::init< SireMaths::Median const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireMaths::Median::accumulate
typedef void ( ::SireMaths::Median::*accumulate_function_type)( double ) ;
accumulate_function_type accumulate_function_value( &::SireMaths::Median::accumulate );
Median_exposer.def(
"accumulate"
, accumulate_function_value
, ( bp::arg("value") )
, "Accumulate the passed value onto the average" );
}
{ //::SireMaths::Median::clear
typedef void ( ::SireMaths::Median::*clear_function_type)( ) ;
clear_function_type clear_function_value( &::SireMaths::Median::clear );
Median_exposer.def(
"clear"
, clear_function_value
, "Completely clear the statistics in this accumulator" );
}
{ //::SireMaths::Median::max
typedef double ( ::SireMaths::Median::*max_function_type)( ) const;
max_function_type max_function_value( &::SireMaths::Median::max );
Median_exposer.def(
"max"
, max_function_value
, "Return the maximum value" );
}
{ //::SireMaths::Median::maximum
typedef double ( ::SireMaths::Median::*maximum_function_type)( ) const;
maximum_function_type maximum_function_value( &::SireMaths::Median::maximum );
Median_exposer.def(
"maximum"
, maximum_function_value
, "Return the maximum value" );
}
{ //::SireMaths::Median::median
typedef double ( ::SireMaths::Median::*median_function_type)( ) const;
median_function_type median_function_value( &::SireMaths::Median::median );
Median_exposer.def(
"median"
, median_function_value
, "Return the median value" );
}
{ //::SireMaths::Median::min
typedef double ( ::SireMaths::Median::*min_function_type)( ) const;
min_function_type min_function_value( &::SireMaths::Median::min );
Median_exposer.def(
"min"
, min_function_value
, "Return the minimum value" );
}
{ //::SireMaths::Median::minimum
typedef double ( ::SireMaths::Median::*minimum_function_type)( ) const;
minimum_function_type minimum_function_value( &::SireMaths::Median::minimum );
Median_exposer.def(
"minimum"
, minimum_function_value
, "Return the minimum value" );
}
Median_exposer.def( bp::self != bp::self );
{ //::SireMaths::Median::operator=
typedef ::SireMaths::Median & ( ::SireMaths::Median::*assign_function_type)( ::SireMaths::Median const & ) ;
assign_function_type assign_function_value( &::SireMaths::Median::operator= );
Median_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
Median_exposer.def( bp::self == bp::self );
{ //::SireMaths::Median::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMaths::Median::typeName );
Median_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
Median_exposer.staticmethod( "typeName" );
Median_exposer.def( "__copy__", &__copy__);
Median_exposer.def( "__deepcopy__", &__copy__);
Median_exposer.def( "clone", &__copy__);
Median_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMaths::Median >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Median_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMaths::Median >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Median_exposer.def( "__str__", &__str__< ::SireMaths::Median > );
Median_exposer.def( "__repr__", &__str__< ::SireMaths::Median > );
}
}