void register_Molecules_class(){
{ //::SireMol::Molecules
typedef bp::class_< SireMol::Molecules, bp::bases< SireBase::Property > > Molecules_exposer_t;
Molecules_exposer_t Molecules_exposer = Molecules_exposer_t( "Molecules", bp::init< >() );
bp::scope Molecules_scope( Molecules_exposer );
Molecules_exposer.def( bp::init< SireMol::MoleculeView const & >(( bp::arg("molecule") )) );
Molecules_exposer.def( bp::init< SireMol::ViewsOfMol const & >(( bp::arg("molviews") )) );
Molecules_exposer.def( bp::init< SireMol::Molecules const & >(( bp::arg("other") )) );
{ //::SireMol::Molecules::add
typedef void ( ::SireMol::Molecules::*add_function_type )( ::SireMol::MoleculeView const & ) ;
add_function_type add_function_value( &::SireMol::Molecules::add );
Molecules_exposer.def(
"add"
, add_function_value
, ( bp::arg("molview") ) );
}
{ //::SireMol::Molecules::add
typedef void ( ::SireMol::Molecules::*add_function_type )( ::SireMol::ViewsOfMol const & ) ;
add_function_type add_function_value( &::SireMol::Molecules::add );
Molecules_exposer.def(
"add"
, add_function_value
, ( bp::arg("molviews") ) );
}
{ //::SireMol::Molecules::add
typedef void ( ::SireMol::Molecules::*add_function_type )( ::SireMol::Molecules const & ) ;
add_function_type add_function_value( &::SireMol::Molecules::add );
Molecules_exposer.def(
"add"
, add_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireMol::Molecules::addIfUnique
typedef bool ( ::SireMol::Molecules::*addIfUnique_function_type )( ::SireMol::MoleculeView const & ) ;
addIfUnique_function_type addIfUnique_function_value( &::SireMol::Molecules::addIfUnique );
Molecules_exposer.def(
"addIfUnique"
, addIfUnique_function_value
, ( bp::arg("molview") ) );
}
{ //::SireMol::Molecules::addIfUnique
typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*addIfUnique_function_type )( ::SireMol::ViewsOfMol const & ) ;
addIfUnique_function_type addIfUnique_function_value( &::SireMol::Molecules::addIfUnique );
Molecules_exposer.def(
"addIfUnique"
, addIfUnique_function_value
, ( bp::arg("molviews") ) );
}
{ //::SireMol::Molecules::addIfUnique
typedef ::QList< SireMol::ViewsOfMol > ( ::SireMol::Molecules::*addIfUnique_function_type )( ::SireMol::Molecules const & ) ;
addIfUnique_function_type addIfUnique_function_value( &::SireMol::Molecules::addIfUnique );
Molecules_exposer.def(
"addIfUnique"
, addIfUnique_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireMol::Molecules::assertContains
typedef void ( ::SireMol::Molecules::*assertContains_function_type )( ::SireMol::MolNum ) const;
assertContains_function_type assertContains_function_value( &::SireMol::Molecules::assertContains );
Molecules_exposer.def(
"assertContains"
, assertContains_function_value
, ( bp::arg("molnum") ) );
}
{ //::SireMol::Molecules::at
typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*at_function_type )( ::SireMol::MolNum ) const;
at_function_type at_function_value( &::SireMol::Molecules::at );
Molecules_exposer.def(
"at"
, at_function_value
, ( bp::arg("molnum") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::Molecules::at
typedef ::SireMol::PartialMolecule ( ::SireMol::Molecules::*at_function_type )( ::boost::tuples::tuple< SireMol::MolNum, SireID::Index, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type > const & ) const;
at_function_type at_function_value( &::SireMol::Molecules::at );
Molecules_exposer.def(
"at"
, at_function_value
, ( bp::arg("viewidx") ) );
}
{ //::SireMol::Molecules::at
typedef ::SireMol::PartialMolecule ( ::SireMol::Molecules::*at_function_type )( ::SireMol::MolNum,int ) const;
at_function_type at_function_value( &::SireMol::Molecules::at );
Molecules_exposer.def(
"at"
, at_function_value
, ( bp::arg("molnum"), bp::arg("idx") ) );
}
{ //::SireMol::Molecules::back
typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*back_function_type )( ) const;
back_function_type back_function_value( &::SireMol::Molecules::back );
Molecules_exposer.def(
"back"
, back_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::Molecules::begin
typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*begin_function_type )( ) const;
begin_function_type begin_function_value( &::SireMol::Molecules::begin );
Molecules_exposer.def(
"begin"
, begin_function_value );
}
{ //::SireMol::Molecules::clear
typedef void ( ::SireMol::Molecules::*clear_function_type )( ) ;
clear_function_type clear_function_value( &::SireMol::Molecules::clear );
Molecules_exposer.def(
"clear"
, clear_function_value );
}
{ //::SireMol::Molecules::constBegin
typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*constBegin_function_type )( ) const;
constBegin_function_type constBegin_function_value( &::SireMol::Molecules::constBegin );
Molecules_exposer.def(
"constBegin"
, constBegin_function_value );
}
{ //::SireMol::Molecules::constEnd
typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*constEnd_function_type )( ) const;
constEnd_function_type constEnd_function_value( &::SireMol::Molecules::constEnd );
Molecules_exposer.def(
"constEnd"
, constEnd_function_value );
}
{ //::SireMol::Molecules::constFind
typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*constFind_function_type )( ::SireMol::MolNum ) const;
constFind_function_type constFind_function_value( &::SireMol::Molecules::constFind );
Molecules_exposer.def(
"constFind"
, constFind_function_value
, ( bp::arg("molnum") ) );
}
{ //::SireMol::Molecules::contains
typedef bool ( ::SireMol::Molecules::*contains_function_type )( ::SireMol::MolNum ) const;
contains_function_type contains_function_value( &::SireMol::Molecules::contains );
Molecules_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("molnum") ) );
}
{ //::SireMol::Molecules::contains
typedef bool ( ::SireMol::Molecules::*contains_function_type )( ::SireMol::MoleculeView const & ) const;
contains_function_type contains_function_value( &::SireMol::Molecules::contains );
Molecules_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("molview") ) );
}
{ //::SireMol::Molecules::contains
typedef bool ( ::SireMol::Molecules::*contains_function_type )( ::SireMol::ViewsOfMol const & ) const;
contains_function_type contains_function_value( &::SireMol::Molecules::contains );
Molecules_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("molviews") ) );
}
{ //::SireMol::Molecules::contains
typedef bool ( ::SireMol::Molecules::*contains_function_type )( ::SireMol::Molecules const & ) const;
contains_function_type contains_function_value( &::SireMol::Molecules::contains );
Molecules_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireMol::Molecules::count
typedef int ( ::SireMol::Molecules::*count_function_type )( ) const;
count_function_type count_function_value( &::SireMol::Molecules::count );
Molecules_exposer.def(
"count"
, count_function_value );
}
{ //::SireMol::Molecules::end
typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*end_function_type )( ) const;
end_function_type end_function_value( &::SireMol::Molecules::end );
Molecules_exposer.def(
"end"
, end_function_value );
}
{ //::SireMol::Molecules::find
typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*find_function_type )( ::SireMol::MolNum ) const;
find_function_type find_function_value( &::SireMol::Molecules::find );
Molecules_exposer.def(
"find"
, find_function_value
, ( bp::arg("molnum") ) );
}
{ //::SireMol::Molecules::first
typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*first_function_type )( ) const;
first_function_type first_function_value( &::SireMol::Molecules::first );
Molecules_exposer.def(
"first"
, first_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::Molecules::front
typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*front_function_type )( ) const;
front_function_type front_function_value( &::SireMol::Molecules::front );
Molecules_exposer.def(
"front"
, front_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::Molecules::intersects
typedef bool ( ::SireMol::Molecules::*intersects_function_type )( ::SireMol::MoleculeView const & ) const;
intersects_function_type intersects_function_value( &::SireMol::Molecules::intersects );
Molecules_exposer.def(
"intersects"
, intersects_function_value
, ( bp::arg("molview") ) );
}
{ //::SireMol::Molecules::intersects
typedef bool ( ::SireMol::Molecules::*intersects_function_type )( ::SireMol::Molecules const & ) const;
intersects_function_type intersects_function_value( &::SireMol::Molecules::intersects );
Molecules_exposer.def(
"intersects"
, intersects_function_value
, ( bp::arg("other") ) );
}
{ //::SireMol::Molecules::isEmpty
typedef bool ( ::SireMol::Molecules::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireMol::Molecules::isEmpty );
Molecules_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireMol::Molecules::last
typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*last_function_type )( ) const;
last_function_type last_function_value( &::SireMol::Molecules::last );
Molecules_exposer.def(
"last"
, last_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::Molecules::molNums
typedef ::QSet< SireMol::MolNum > ( ::SireMol::Molecules::*molNums_function_type )( ) const;
molNums_function_type molNums_function_value( &::SireMol::Molecules::molNums );
Molecules_exposer.def(
"molNums"
, molNums_function_value );
}
{ //::SireMol::Molecules::molecule
typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*molecule_function_type )( ::SireMol::MolNum ) const;
molecule_function_type molecule_function_value( &::SireMol::Molecules::molecule );
Molecules_exposer.def(
"molecule"
, molecule_function_value
, ( bp::arg("molnum") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::Molecules::nMolecules
typedef int ( ::SireMol::Molecules::*nMolecules_function_type )( ) const;
nMolecules_function_type nMolecules_function_value( &::SireMol::Molecules::nMolecules );
Molecules_exposer.def(
"nMolecules"
, nMolecules_function_value );
}
{ //::SireMol::Molecules::nViews
typedef int ( ::SireMol::Molecules::*nViews_function_type )( ) const;
nViews_function_type nViews_function_value( &::SireMol::Molecules::nViews );
Molecules_exposer.def(
"nViews"
, nViews_function_value );
}
{ //::SireMol::Molecules::nViews
typedef int ( ::SireMol::Molecules::*nViews_function_type )( ::SireMol::MolNum ) const;
nViews_function_type nViews_function_value( &::SireMol::Molecules::nViews );
Molecules_exposer.def(
"nViews"
, nViews_function_value
, ( bp::arg("molnum") ) );
}
Molecules_exposer.def( bp::self != bp::self );
Molecules_exposer.def( bp::self + bp::self );
Molecules_exposer.def( bp::self - bp::self );
{ //::SireMol::Molecules::operator=
typedef ::SireMol::Molecules & ( ::SireMol::Molecules::*assign_function_type )( ::SireMol::Molecules const & ) ;
assign_function_type assign_function_value( &::SireMol::Molecules::operator= );
Molecules_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
Molecules_exposer.def( bp::self == bp::self );
{ //::SireMol::Molecules::operator[]
typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*__getitem___function_type )( ::SireMol::MolNum ) const;
__getitem___function_type __getitem___function_value( &::SireMol::Molecules::operator[] );
Molecules_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("molnum") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::Molecules::operator[]
typedef ::SireMol::PartialMolecule ( ::SireMol::Molecules::*__getitem___function_type )( ::boost::tuples::tuple< SireMol::MolNum, SireID::Index, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type > const & ) const;
__getitem___function_type __getitem___function_value( &::SireMol::Molecules::operator[] );
Molecules_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("viewidx") ) );
}
{ //::SireMol::Molecules::remove
typedef bool ( ::SireMol::Molecules::*remove_function_type )( ::SireMol::MoleculeView const & ) ;
remove_function_type remove_function_value( &::SireMol::Molecules::remove );
Molecules_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("molview") ) );
}
{ //::SireMol::Molecules::remove
typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*remove_function_type )( ::SireMol::ViewsOfMol const & ) ;
remove_function_type remove_function_value( &::SireMol::Molecules::remove );
Molecules_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("molviews") ) );
}
{ //::SireMol::Molecules::remove
typedef ::QList< SireMol::ViewsOfMol > ( ::SireMol::Molecules::*remove_function_type )( ::SireMol::Molecules const & ) ;
remove_function_type remove_function_value( &::SireMol::Molecules::remove );
Molecules_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireMol::Molecules::remove
typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*remove_function_type )( ::SireMol::MolNum ) ;
remove_function_type remove_function_value( &::SireMol::Molecules::remove );
Molecules_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("molnum") ) );
}
{ //::SireMol::Molecules::removeAll
typedef bool ( ::SireMol::Molecules::*removeAll_function_type )( ::SireMol::MoleculeView const & ) ;
removeAll_function_type removeAll_function_value( &::SireMol::Molecules::removeAll );
Molecules_exposer.def(
"removeAll"
, removeAll_function_value
, ( bp::arg("molview") ) );
}
{ //::SireMol::Molecules::removeAll
typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*removeAll_function_type )( ::SireMol::ViewsOfMol const & ) ;
removeAll_function_type removeAll_function_value( &::SireMol::Molecules::removeAll );
Molecules_exposer.def(
"removeAll"
, removeAll_function_value
, ( bp::arg("molviews") ) );
}
{ //::SireMol::Molecules::removeAll
typedef ::QList< SireMol::ViewsOfMol > ( ::SireMol::Molecules::*removeAll_function_type )( ::SireMol::Molecules const & ) ;
removeAll_function_type removeAll_function_value( &::SireMol::Molecules::removeAll );
Molecules_exposer.def(
"removeAll"
, removeAll_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireMol::Molecules::removeAll
typedef bool ( ::SireMol::Molecules::*removeAll_function_type )( ) ;
removeAll_function_type removeAll_function_value( &::SireMol::Molecules::removeAll );
Molecules_exposer.def(
"removeAll"
, removeAll_function_value );
}
{ //::SireMol::Molecules::removeDuplicates
typedef bool ( ::SireMol::Molecules::*removeDuplicates_function_type )( ) ;
removeDuplicates_function_type removeDuplicates_function_value( &::SireMol::Molecules::removeDuplicates );
Molecules_exposer.def(
"removeDuplicates"
, removeDuplicates_function_value );
}
{ //::SireMol::Molecules::reserve
typedef void ( ::SireMol::Molecules::*reserve_function_type )( int ) ;
reserve_function_type reserve_function_value( &::SireMol::Molecules::reserve );
Molecules_exposer.def(
"reserve"
, reserve_function_value
, ( bp::arg("nmolecules") ) );
}
{ //::SireMol::Molecules::toString
typedef ::QString ( ::SireMol::Molecules::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMol::Molecules::toString );
Molecules_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMol::Molecules::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::Molecules::typeName );
Molecules_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMol::Molecules::unite
typedef bool ( ::SireMol::Molecules::*unite_function_type )( ::SireMol::MoleculeView const & ) ;
unite_function_type unite_function_value( &::SireMol::Molecules::unite );
Molecules_exposer.def(
"unite"
, unite_function_value
, ( bp::arg("molview") ) );
}
{ //::SireMol::Molecules::unite
typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*unite_function_type )( ::SireMol::ViewsOfMol const & ) ;
unite_function_type unite_function_value( &::SireMol::Molecules::unite );
Molecules_exposer.def(
"unite"
, unite_function_value
, ( bp::arg("molviews") ) );
}
{ //::SireMol::Molecules::unite
typedef ::QList< SireMol::ViewsOfMol > ( ::SireMol::Molecules::*unite_function_type )( ::SireMol::Molecules const & ) ;
unite_function_type unite_function_value( &::SireMol::Molecules::unite );
Molecules_exposer.def(
"unite"
, unite_function_value
, ( bp::arg("other") ) );
}
{ //::SireMol::Molecules::uniteViews
typedef bool ( ::SireMol::Molecules::*uniteViews_function_type )( ) ;
uniteViews_function_type uniteViews_function_value( &::SireMol::Molecules::uniteViews );
Molecules_exposer.def(
"uniteViews"
, uniteViews_function_value );
}
{ //::SireMol::Molecules::update
typedef bool ( ::SireMol::Molecules::*update_function_type )( ::SireMol::MoleculeData const & ) ;
update_function_type update_function_value( &::SireMol::Molecules::update );
Molecules_exposer.def(
"update"
, update_function_value
, ( bp::arg("moldata") ) );
}
{ //::SireMol::Molecules::update
typedef bool ( ::SireMol::Molecules::*update_function_type )( ::SireMol::MoleculeView const & ) ;
update_function_type update_function_value( &::SireMol::Molecules::update );
Molecules_exposer.def(
"update"
, update_function_value
, ( bp::arg("molview") ) );
}
{ //::SireMol::Molecules::update
typedef ::QList< SireMol::Molecule > ( ::SireMol::Molecules::*update_function_type )( ::SireMol::Molecules const & ) ;
update_function_type update_function_value( &::SireMol::Molecules::update );
Molecules_exposer.def(
"update"
, update_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireMol::Molecules::what
typedef char const * ( ::SireMol::Molecules::*what_function_type )( ) const;
what_function_type what_function_value( &::SireMol::Molecules::what );
Molecules_exposer.def(
"what"
, what_function_value );
}
Molecules_exposer.staticmethod( "typeName" );
Molecules_exposer.def( "__copy__", &__copy__);
Molecules_exposer.def( "__deepcopy__", &__copy__);
Molecules_exposer.def( "clone", &__copy__);
Molecules_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::Molecules >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Molecules_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::Molecules >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Molecules_exposer.def( "__str__", &__str__< ::SireMol::Molecules > );
Molecules_exposer.def( "__repr__", &__str__< ::SireMol::Molecules > );
Molecules_exposer.def( "__len__", &__len_count< ::SireMol::Molecules > );
}
}
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_CLJWorkspace_class(){
{ //::SireMM::CLJWorkspace
typedef bp::class_< SireMM::CLJWorkspace > CLJWorkspace_exposer_t;
CLJWorkspace_exposer_t CLJWorkspace_exposer = CLJWorkspace_exposer_t( "CLJWorkspace", "This class provides a workspace in which to hold the details of the changes\nthat occur in a CLJ forcefield during a Monte Carlo move. The class is optimised\nto avoid copying or duplicating data during Sires copy-on-write copying\n(e.g. the memory allocated in a workspace will always be available for the\nnew copy of a forcefield rather than the old, which, if things work correctly,\nwill mean that there should be no memory allocation during simple MC moves...)\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") );
bp::scope CLJWorkspace_scope( CLJWorkspace_exposer );
CLJWorkspace_exposer.def( bp::init< SireMM::CLJWorkspace const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireMM::CLJWorkspace::accept
typedef void ( ::SireMM::CLJWorkspace::*accept_function_type)( ::SireMM::CLJBoxes & ) ;
accept_function_type accept_function_value( &::SireMM::CLJWorkspace::accept );
CLJWorkspace_exposer.def(
"accept"
, accept_function_value
, ( bp::arg("boxes") )
, "Accept this workspace - this clears the recalc_from_scratch flag as it\nsignals that we have put the CLJBoxes into a sane state" );
}
{ //::SireMM::CLJWorkspace::at
typedef ::SireMM::CLJDelta const & ( ::SireMM::CLJWorkspace::*at_function_type)( int ) const;
at_function_type at_function_value( &::SireMM::CLJWorkspace::at );
CLJWorkspace_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the ith delta" );
}
{ //::SireMM::CLJWorkspace::changedAtoms
typedef ::SireMM::CLJAtoms ( ::SireMM::CLJWorkspace::*changedAtoms_function_type)( ) const;
changedAtoms_function_type changedAtoms_function_value( &::SireMM::CLJWorkspace::changedAtoms );
CLJWorkspace_exposer.def(
"changedAtoms"
, changedAtoms_function_value
, "Merge all of the deltas together into a single set of changed CLJAtoms that\ncan be used for the change in energy calculation" );
}
{ //::SireMM::CLJWorkspace::clear
typedef void ( ::SireMM::CLJWorkspace::*clear_function_type)( ) ;
clear_function_type clear_function_value( &::SireMM::CLJWorkspace::clear );
CLJWorkspace_exposer.def(
"clear"
, clear_function_value
, "Clear this workspace" );
}
{ //::SireMM::CLJWorkspace::commit
typedef ::QVector< SireMM::CLJBoxIndex > ( ::SireMM::CLJWorkspace::*commit_function_type)( ::SireMM::CLJBoxes &,::SireMM::CLJDelta const & ) ;
commit_function_type commit_function_value( &::SireMM::CLJWorkspace::commit );
CLJWorkspace_exposer.def(
"commit"
, commit_function_value
, ( bp::arg("boxes"), bp::arg("delta") )
, "Commit the changes in the passed delta into the passed CLJBoxes" );
}
{ //::SireMM::CLJWorkspace::count
typedef int ( ::SireMM::CLJWorkspace::*count_function_type)( ) const;
count_function_type count_function_value( &::SireMM::CLJWorkspace::count );
CLJWorkspace_exposer.def(
"count"
, count_function_value
, "Return the number of deltas" );
}
{ //::SireMM::CLJWorkspace::getitem
typedef ::SireMM::CLJDelta ( ::SireMM::CLJWorkspace::*getitem_function_type)( int ) const;
getitem_function_type getitem_function_value( &::SireMM::CLJWorkspace::getitem );
CLJWorkspace_exposer.def(
"getitem"
, getitem_function_value
, ( bp::arg("i") )
, "Return the ith delta" );
}
{ //::SireMM::CLJWorkspace::isEmpty
typedef bool ( ::SireMM::CLJWorkspace::*isEmpty_function_type)( ) const;
isEmpty_function_type isEmpty_function_value( &::SireMM::CLJWorkspace::isEmpty );
CLJWorkspace_exposer.def(
"isEmpty"
, isEmpty_function_value
, "Return whether or not this workspace is empty" );
}
{ //::SireMM::CLJWorkspace::isSingleID
typedef bool ( ::SireMM::CLJWorkspace::*isSingleID_function_type)( ) const;
isSingleID_function_type isSingleID_function_value( &::SireMM::CLJWorkspace::isSingleID );
CLJWorkspace_exposer.def(
"isSingleID"
, isSingleID_function_value
, "Return whether or not this workspace contains deltas with a single\nID (a single CLJAtoms ID)" );
}
{ //::SireMM::CLJWorkspace::merge
typedef ::boost::tuples::tuple< SireMM::CLJAtoms, SireMM::CLJAtoms, SireMM::CLJAtoms, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type > ( ::SireMM::CLJWorkspace::*merge_function_type)( ) const;
merge_function_type merge_function_value( &::SireMM::CLJWorkspace::merge );
CLJWorkspace_exposer.def(
"merge"
, merge_function_value
, "Merge all of the deltas together to return the tuple of the\nchanged, old and new atoms. This is equivalent to calling\nchangedAtoms(), oldAtoms() and newAtoms() and placing them\ninto a tuple. This is more efficient than three separate calls" );
}
{ //::SireMM::CLJWorkspace::mustRecalculateFromScratch
typedef void ( ::SireMM::CLJWorkspace::*mustRecalculateFromScratch_function_type)( ::SireMM::CLJBoxes & ) ;
mustRecalculateFromScratch_function_type mustRecalculateFromScratch_function_value( &::SireMM::CLJWorkspace::mustRecalculateFromScratch );
CLJWorkspace_exposer.def(
"mustRecalculateFromScratch"
, mustRecalculateFromScratch_function_value
, ( bp::arg("boxes") )
, "Tell the workspace that we are now recalculating everything from scratch" );
}
{ //::SireMM::CLJWorkspace::nDeltas
typedef int ( ::SireMM::CLJWorkspace::*nDeltas_function_type)( ) const;
nDeltas_function_type nDeltas_function_value( &::SireMM::CLJWorkspace::nDeltas );
CLJWorkspace_exposer.def(
"nDeltas"
, nDeltas_function_value
, "Return the number of deltas in this workspace" );
}
{ //::SireMM::CLJWorkspace::needsAccepting
typedef bool ( ::SireMM::CLJWorkspace::*needsAccepting_function_type)( ) const;
needsAccepting_function_type needsAccepting_function_value( &::SireMM::CLJWorkspace::needsAccepting );
CLJWorkspace_exposer.def(
"needsAccepting"
, needsAccepting_function_value
, "Return whether or not this workspace needs accepting" );
}
{ //::SireMM::CLJWorkspace::newAtoms
typedef ::SireMM::CLJAtoms ( ::SireMM::CLJWorkspace::*newAtoms_function_type)( ) const;
newAtoms_function_type newAtoms_function_value( &::SireMM::CLJWorkspace::newAtoms );
CLJWorkspace_exposer.def(
"newAtoms"
, newAtoms_function_value
, "Merge all of the new atoms from the deltas together into a single\nset of new CLJAtoms that can be used for the change in energy calculation" );
}
{ //::SireMM::CLJWorkspace::oldAtoms
typedef ::SireMM::CLJAtoms ( ::SireMM::CLJWorkspace::*oldAtoms_function_type)( ) const;
oldAtoms_function_type oldAtoms_function_value( &::SireMM::CLJWorkspace::oldAtoms );
CLJWorkspace_exposer.def(
"oldAtoms"
, oldAtoms_function_value
, "Merge all of the old atoms from the deltas together into a single\nset of old CLJAtoms that can be used for the change in energy calculation" );
}
CLJWorkspace_exposer.def( bp::self != bp::self );
{ //::SireMM::CLJWorkspace::operator=
typedef ::SireMM::CLJWorkspace & ( ::SireMM::CLJWorkspace::*assign_function_type)( ::SireMM::CLJWorkspace const & ) ;
assign_function_type assign_function_value( &::SireMM::CLJWorkspace::operator= );
CLJWorkspace_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
CLJWorkspace_exposer.def( bp::self == bp::self );
{ //::SireMM::CLJWorkspace::operator[]
typedef ::SireMM::CLJDelta const & ( ::SireMM::CLJWorkspace::*__getitem___function_type)( int ) const;
__getitem___function_type __getitem___function_value( &::SireMM::CLJWorkspace::operator[] );
CLJWorkspace_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMM::CLJWorkspace::push
typedef ::SireMM::CLJDelta ( ::SireMM::CLJWorkspace::*push_function_type)( ::SireMM::CLJBoxes &,::QVector< SireMM::CLJBoxIndex > const &,::SireMM::CLJAtoms const &,::SireMM::CLJDelta const & ) ;
push_function_type push_function_value( &::SireMM::CLJWorkspace::push );
CLJWorkspace_exposer.def(
"push"
, push_function_value
, ( bp::arg("boxes"), bp::arg("old_atoms"), bp::arg("new_atoms"), bp::arg("old_delta") )
, "Push the passed change onto the workspace. This changes the atoms in the\npassed CLJBoxes from their values in old_atoms to their values in the\npassed new_atoms. The last CLJDelta used for these atoms is supplied as\nold_delta, and this returns the new CLJDelta for these atoms." );
}
{ //::SireMM::CLJWorkspace::recalculatingFromScratch
typedef bool ( ::SireMM::CLJWorkspace::*recalculatingFromScratch_function_type)( ) const;
recalculatingFromScratch_function_type recalculatingFromScratch_function_value( &::SireMM::CLJWorkspace::recalculatingFromScratch );
CLJWorkspace_exposer.def(
"recalculatingFromScratch"
, recalculatingFromScratch_function_value
, "Return whether or not we are recalculating everything from scratch" );
}
{ //::SireMM::CLJWorkspace::removeSameIDAtoms
typedef void ( ::SireMM::CLJWorkspace::*removeSameIDAtoms_function_type)( ::SireMM::CLJBoxes & ) ;
removeSameIDAtoms_function_type removeSameIDAtoms_function_value( &::SireMM::CLJWorkspace::removeSameIDAtoms );
CLJWorkspace_exposer.def(
"removeSameIDAtoms"
, removeSameIDAtoms_function_value
, ( bp::arg("boxes") )
, "Internal function used to fully remove atoms that have not been\nremoved because they all have the same ID. This is used when the\noptimisation of not removing same ID atoms would break the energy\ncalculation, e.g. if we have multiple CLJGroups and have multiple\nchanged IDs across these groups" );
}
{ //::SireMM::CLJWorkspace::revert
typedef ::QVector< SireMM::CLJBoxIndex > ( ::SireMM::CLJWorkspace::*revert_function_type)( ::SireMM::CLJBoxes &,::SireMM::CLJDelta const & ) ;
revert_function_type revert_function_value( &::SireMM::CLJWorkspace::revert );
CLJWorkspace_exposer.def(
"revert"
, revert_function_value
, ( bp::arg("boxes"), bp::arg("delta") )
, "Revert the changes supplied in the passed delta" );
}
{ //::SireMM::CLJWorkspace::size
typedef int ( ::SireMM::CLJWorkspace::*size_function_type)( ) const;
size_function_type size_function_value( &::SireMM::CLJWorkspace::size );
CLJWorkspace_exposer.def(
"size"
, size_function_value
, "Return the number of deltas" );
}
{ //::SireMM::CLJWorkspace::toString
typedef ::QString ( ::SireMM::CLJWorkspace::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMM::CLJWorkspace::toString );
CLJWorkspace_exposer.def(
"toString"
, toString_function_value
, "" );
}
{ //::SireMM::CLJWorkspace::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMM::CLJWorkspace::typeName );
CLJWorkspace_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireMM::CLJWorkspace::what
typedef char const * ( ::SireMM::CLJWorkspace::*what_function_type)( ) const;
what_function_type what_function_value( &::SireMM::CLJWorkspace::what );
CLJWorkspace_exposer.def(
"what"
, what_function_value
, "" );
}
CLJWorkspace_exposer.staticmethod( "typeName" );
CLJWorkspace_exposer.def( "__copy__", &__copy__);
CLJWorkspace_exposer.def( "__deepcopy__", &__copy__);
CLJWorkspace_exposer.def( "clone", &__copy__);
CLJWorkspace_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::CLJWorkspace >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CLJWorkspace_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::CLJWorkspace >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CLJWorkspace_exposer.def( "__str__", &__str__< ::SireMM::CLJWorkspace > );
CLJWorkspace_exposer.def( "__repr__", &__str__< ::SireMM::CLJWorkspace > );
CLJWorkspace_exposer.def( "__len__", &__len_size< ::SireMM::CLJWorkspace > );
CLJWorkspace_exposer.def( "__getitem__", &::SireMM::CLJWorkspace::getitem );
}
}
void register_FEP_class(){
{ //::SireAnalysis::FEP
typedef bp::class_< SireAnalysis::FEP, bp::bases< SireBase::Property > > FEP_exposer_t;
FEP_exposer_t FEP_exposer = FEP_exposer_t( "FEP", "This class is used to analyse the free energies that are\ncalculated during a free energy perturbation (FEP) simulation\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") );
bp::scope FEP_scope( FEP_exposer );
FEP_exposer.def( bp::init< QList< double > const &, QMap< double, SireMaths::FreeEnergyAverage > const & >(( bp::arg("windows"), bp::arg("deltas") ), "Construct to use the passed set of windows, with the free energy deltas from\neach window to the window above") );
FEP_exposer.def( bp::init< QList< double > const &, QMap< double, SireMaths::FreeEnergyAverage > const &, QMap< double, SireMaths::FreeEnergyAverage > const & >(( bp::arg("windows"), bp::arg("forwards_deltas"), bp::arg("backwards_deltas") ), "Construct to use the passed windows, with the free energy deltas from\neach window to the window above in forwards_deltas and from the window\nbelow to each window in backwards_deltas") );
FEP_exposer.def( bp::init< SireAnalysis::FEPDeltas const & >(( bp::arg("deltas") ), "Construct to use the passed FEP deltas") );
FEP_exposer.def( bp::init< SireAnalysis::FEP const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireAnalysis::FEP::add
typedef void ( ::SireAnalysis::FEP::*add_function_type)( ::QList< double > const &,::QMap< double, SireMaths::FreeEnergyAverage > const & ) ;
add_function_type add_function_value( &::SireAnalysis::FEP::add );
FEP_exposer.def(
"add"
, add_function_value
, ( bp::arg("windows"), bp::arg("deltas") )
, "Add the data for the next iteration, which contains the deltas for the passed windows,\nwith the free energy being for each window to the next window" );
}
{ //::SireAnalysis::FEP::add
typedef void ( ::SireAnalysis::FEP::*add_function_type)( ::QList< double > const &,::QMap< double, SireMaths::FreeEnergyAverage > const &,::QMap< double, SireMaths::FreeEnergyAverage > const & ) ;
add_function_type add_function_value( &::SireAnalysis::FEP::add );
FEP_exposer.def(
"add"
, add_function_value
, ( bp::arg("windows"), bp::arg("forwards_deltas"), bp::arg("backwards_deltas") )
, "Add the data for the next iteration, which contains the deltas for the passed windows,\nwith forwards_deltas containing the free energy from each window to the next window,\nand backwards_deltas containing the free energy from the previous window to each window" );
}
{ //::SireAnalysis::FEP::add
typedef void ( ::SireAnalysis::FEP::*add_function_type)( ::SireAnalysis::FEPDeltas const & ) ;
add_function_type add_function_value( &::SireAnalysis::FEP::add );
FEP_exposer.def(
"add"
, add_function_value
, ( bp::arg("deltas") )
, "Add the data for the next iteration" );
}
{ //::SireAnalysis::FEP::at
typedef ::SireAnalysis::FEPDeltas ( ::SireAnalysis::FEP::*at_function_type)( int ) const;
at_function_type at_function_value( &::SireAnalysis::FEP::at );
FEP_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, "Return the deltas for the ith iteration" );
}
{ //::SireAnalysis::FEP::clear
typedef void ( ::SireAnalysis::FEP::*clear_function_type)( ) ;
clear_function_type clear_function_value( &::SireAnalysis::FEP::clear );
FEP_exposer.def(
"clear"
, clear_function_value
, "Remove all values from the histogram" );
}
{ //::SireAnalysis::FEP::count
typedef int ( ::SireAnalysis::FEP::*count_function_type)( ) const;
count_function_type count_function_value( &::SireAnalysis::FEP::count );
FEP_exposer.def(
"count"
, count_function_value
, "Return the number of iterations" );
}
{ //::SireAnalysis::FEP::deltas
typedef ::QList< SireAnalysis::FEPDeltas > ( ::SireAnalysis::FEP::*deltas_function_type)( ) const;
deltas_function_type deltas_function_value( &::SireAnalysis::FEP::deltas );
FEP_exposer.def(
"deltas"
, deltas_function_value
, "Return the deltas for all iterations" );
}
{ //::SireAnalysis::FEP::lambdaValues
typedef ::QList< double > ( ::SireAnalysis::FEP::*lambdaValues_function_type)( ) const;
lambdaValues_function_type lambdaValues_function_value( &::SireAnalysis::FEP::lambdaValues );
FEP_exposer.def(
"lambdaValues"
, lambdaValues_function_value
, "Return the values of all windows" );
}
{ //::SireAnalysis::FEP::merge
typedef ::SireAnalysis::FEPDeltas ( ::SireAnalysis::FEP::*merge_function_type)( int,int ) const;
merge_function_type merge_function_value( &::SireAnalysis::FEP::merge );
FEP_exposer.def(
"merge"
, merge_function_value
, ( bp::arg("start"), bp::arg("end") )
, "Merge the deltas for iterations start->end" );
}
{ //::SireAnalysis::FEP::merge
typedef ::SireAnalysis::FEPDeltas ( ::SireAnalysis::FEP::*merge_function_type)( ::QList< int > ) const;
merge_function_type merge_function_value( &::SireAnalysis::FEP::merge );
FEP_exposer.def(
"merge"
, merge_function_value
, ( bp::arg("indicies") )
, "Merge the deltas at the passed indicies" );
}
{ //::SireAnalysis::FEP::nIterations
typedef int ( ::SireAnalysis::FEP::*nIterations_function_type)( ) const;
nIterations_function_type nIterations_function_value( &::SireAnalysis::FEP::nIterations );
FEP_exposer.def(
"nIterations"
, nIterations_function_value
, "Return the number of iterations" );
}
{ //::SireAnalysis::FEP::nLambdaValues
typedef int ( ::SireAnalysis::FEP::*nLambdaValues_function_type)( ) const;
nLambdaValues_function_type nLambdaValues_function_value( &::SireAnalysis::FEP::nLambdaValues );
FEP_exposer.def(
"nLambdaValues"
, nLambdaValues_function_value
, "Return the number of lambda values (windows)" );
}
{ //::SireAnalysis::FEP::nSamples
typedef ::qint64 ( ::SireAnalysis::FEP::*nSamples_function_type)( ) const;
nSamples_function_type nSamples_function_value( &::SireAnalysis::FEP::nSamples );
FEP_exposer.def(
"nSamples"
, nSamples_function_value
, "Return the total number of samples in the simulation" );
}
{ //::SireAnalysis::FEP::nWindows
typedef int ( ::SireAnalysis::FEP::*nWindows_function_type)( ) const;
nWindows_function_type nWindows_function_value( &::SireAnalysis::FEP::nWindows );
FEP_exposer.def(
"nWindows"
, nWindows_function_value
, "Return the number of windows" );
}
FEP_exposer.def( bp::self != bp::self );
{ //::SireAnalysis::FEP::operator=
typedef ::SireAnalysis::FEP & ( ::SireAnalysis::FEP::*assign_function_type)( ::SireAnalysis::FEP const & ) ;
assign_function_type assign_function_value( &::SireAnalysis::FEP::operator= );
FEP_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
FEP_exposer.def( bp::self == bp::self );
{ //::SireAnalysis::FEP::operator[]
typedef ::SireAnalysis::FEPDeltas ( ::SireAnalysis::FEP::*__getitem___function_type)( int ) const;
__getitem___function_type __getitem___function_value( &::SireAnalysis::FEP::operator[] );
FEP_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, "" );
}
{ //::SireAnalysis::FEP::removeAt
typedef void ( ::SireAnalysis::FEP::*removeAt_function_type)( int ) ;
removeAt_function_type removeAt_function_value( &::SireAnalysis::FEP::removeAt );
FEP_exposer.def(
"removeAt"
, removeAt_function_value
, ( bp::arg("i") )
, "Remove the data for iteration i" );
}
{ //::SireAnalysis::FEP::removeRange
typedef void ( ::SireAnalysis::FEP::*removeRange_function_type)( int,int ) ;
removeRange_function_type removeRange_function_value( &::SireAnalysis::FEP::removeRange );
FEP_exposer.def(
"removeRange"
, removeRange_function_value
, ( bp::arg("start"), bp::arg("end") )
, "Remove every iteration from start to end (inclusively)" );
}
{ //::SireAnalysis::FEP::rollingAverage
typedef ::QList< SireAnalysis::FEPDeltas > ( ::SireAnalysis::FEP::*rollingAverage_function_type)( int ) const;
rollingAverage_function_type rollingAverage_function_value( &::SireAnalysis::FEP::rollingAverage );
FEP_exposer.def(
"rollingAverage"
, rollingAverage_function_value
, ( bp::arg("niterations") )
, "Return a list of Gradients that represents the rolling average over niterations\niterations over this TI data set. If this data set contains 100 iterations, and\nwe calculate the rolling average over 50 iterations, then the returned Gradients\nwill be the average from 1-50, then 2-51, 3-52.....51-100" );
}
{ //::SireAnalysis::FEP::set
typedef void ( ::SireAnalysis::FEP::*set_function_type)( int,::QList< double > const &,::QMap< double, SireMaths::FreeEnergyAverage > const & ) ;
set_function_type set_function_value( &::SireAnalysis::FEP::set );
FEP_exposer.def(
"set"
, set_function_value
, ( bp::arg("i"), bp::arg("windows"), bp::arg("deltas") )
, "Set the deltas for the ith iteration" );
}
{ //::SireAnalysis::FEP::set
typedef void ( ::SireAnalysis::FEP::*set_function_type)( int,::QList< double > const &,::QMap< double, SireMaths::FreeEnergyAverage > const &,::QMap< double, SireMaths::FreeEnergyAverage > const & ) ;
set_function_type set_function_value( &::SireAnalysis::FEP::set );
FEP_exposer.def(
"set"
, set_function_value
, ( bp::arg("i"), bp::arg("windows"), bp::arg("forwards_deltas"), bp::arg("backwards_deltas") )
, "Set the deltas for the ith iteration" );
}
{ //::SireAnalysis::FEP::set
typedef void ( ::SireAnalysis::FEP::*set_function_type)( int,::SireAnalysis::FEPDeltas const & ) ;
set_function_type set_function_value( &::SireAnalysis::FEP::set );
FEP_exposer.def(
"set"
, set_function_value
, ( bp::arg("i"), bp::arg("deltas") )
, "Set the deltas for the ith iteration" );
}
{ //::SireAnalysis::FEP::size
typedef int ( ::SireAnalysis::FEP::*size_function_type)( ) const;
size_function_type size_function_value( &::SireAnalysis::FEP::size );
FEP_exposer.def(
"size"
, size_function_value
, "Return the number of iterations" );
}
{ //::SireAnalysis::FEP::toString
typedef ::QString ( ::SireAnalysis::FEP::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireAnalysis::FEP::toString );
FEP_exposer.def(
"toString"
, toString_function_value
, "" );
}
{ //::SireAnalysis::FEP::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireAnalysis::FEP::typeName );
FEP_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireAnalysis::FEP::what
typedef char const * ( ::SireAnalysis::FEP::*what_function_type)( ) const;
what_function_type what_function_value( &::SireAnalysis::FEP::what );
FEP_exposer.def(
"what"
, what_function_value
, "" );
}
{ //::SireAnalysis::FEP::windows
typedef ::QList< double > ( ::SireAnalysis::FEP::*windows_function_type)( ) const;
windows_function_type windows_function_value( &::SireAnalysis::FEP::windows );
FEP_exposer.def(
"windows"
, windows_function_value
, "Return the value of all windows" );
}
FEP_exposer.staticmethod( "typeName" );
FEP_exposer.def( "__copy__", &__copy__);
FEP_exposer.def( "__deepcopy__", &__copy__);
FEP_exposer.def( "clone", &__copy__);
FEP_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireAnalysis::FEP >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
FEP_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireAnalysis::FEP >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
FEP_exposer.def( "__str__", &__str__< ::SireAnalysis::FEP > );
FEP_exposer.def( "__repr__", &__str__< ::SireAnalysis::FEP > );
FEP_exposer.def( "__len__", &__len_size< ::SireAnalysis::FEP > );
}
}
void register_ChunkedVector_double__class(){
{ //::SireBase::ChunkedVector< double, 100 >
typedef bp::class_< SireBase::ChunkedVector< double, 100 > > ChunkedVector_double__exposer_t;
ChunkedVector_double__exposer_t ChunkedVector_double__exposer = ChunkedVector_double__exposer_t( "ChunkedVector_double_", bp::init< >() );
bp::scope ChunkedVector_double__scope( ChunkedVector_double__exposer );
{ //::SireBase::ChunkedVector< double, 100 >::const_iterator
typedef bp::class_< SireBase::ChunkedVector< double, 100 >::const_iterator > const_iterator_exposer_t;
const_iterator_exposer_t const_iterator_exposer = const_iterator_exposer_t( "const_iterator", bp::init< >() );
bp::scope const_iterator_scope( const_iterator_exposer );
const_iterator_exposer.def( bp::init< SireBase::ChunkedVector< double, 100 >::const_iterator const & >(( bp::arg("other") )) );
const_iterator_exposer.def( bp::self != bp::self );
{ //::SireBase::ChunkedVector< double, 100 >::const_iterator::operator=
typedef ::SireBase::ChunkedVector< double, 100 >::const_iterator & ( ::SireBase::ChunkedVector< double, 100 >::const_iterator::*assign_function_type )( ::SireBase::ChunkedVector< double, 100 >::const_iterator const & ) ;
assign_function_type assign_function_value( &::SireBase::ChunkedVector< double, 100 >::const_iterator::operator= );
const_iterator_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
const_iterator_exposer.def( bp::self == bp::self );
}
{ //::SireBase::ChunkedVector< double, 100 >::iterator
typedef bp::class_< SireBase::ChunkedVector< double, 100 >::iterator > iterator_exposer_t;
iterator_exposer_t iterator_exposer = iterator_exposer_t( "iterator", bp::init< >() );
bp::scope iterator_scope( iterator_exposer );
iterator_exposer.def( bp::init< SireBase::ChunkedVector< double, 100 >::iterator const & >(( bp::arg("other") )) );
iterator_exposer.def( bp::self != bp::self );
{ //::SireBase::ChunkedVector< double, 100 >::iterator::operator=
typedef ::SireBase::ChunkedVector< double, 100 >::iterator & ( ::SireBase::ChunkedVector< double, 100 >::iterator::*assign_function_type )( ::SireBase::ChunkedVector< double, 100 >::iterator const & ) ;
assign_function_type assign_function_value( &::SireBase::ChunkedVector< double, 100 >::iterator::operator= );
iterator_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
iterator_exposer.def( bp::self == bp::self );
}
ChunkedVector_double__exposer.def( bp::init< int >(( bp::arg("size") )) );
ChunkedVector_double__exposer.def( bp::init< int, double const & >(( bp::arg("size"), bp::arg("value") )) );
ChunkedVector_double__exposer.def( bp::init< SireBase::ChunkedVector< double, 100 > const & >(( bp::arg("other") )) );
{ //::SireBase::ChunkedVector< double, 100 >::append
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef void ( ::SireBase::ChunkedVector< double, 100 >::*append_function_type )( double const & ) ;
append_function_type append_function_value( &::SireBase::ChunkedVector< double, 100 >::append );
ChunkedVector_double__exposer.def(
"append"
, append_function_value
, ( bp::arg("value") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::at
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef double const & ( ::SireBase::ChunkedVector< double, 100 >::*at_function_type )( int ) const;
at_function_type at_function_value( &::SireBase::ChunkedVector< double, 100 >::at );
ChunkedVector_double__exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireBase::ChunkedVector< double, 100 >::begin
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 >::iterator ( ::SireBase::ChunkedVector< double, 100 >::*begin_function_type )( ) ;
begin_function_type begin_function_value( &::SireBase::ChunkedVector< double, 100 >::begin );
ChunkedVector_double__exposer.def(
"begin"
, begin_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::begin
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 >::const_iterator ( ::SireBase::ChunkedVector< double, 100 >::*begin_function_type )( ) const;
begin_function_type begin_function_value( &::SireBase::ChunkedVector< double, 100 >::begin );
ChunkedVector_double__exposer.def(
"begin"
, begin_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::capacity
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef int ( ::SireBase::ChunkedVector< double, 100 >::*capacity_function_type )( ) const;
capacity_function_type capacity_function_value( &::SireBase::ChunkedVector< double, 100 >::capacity );
ChunkedVector_double__exposer.def(
"capacity"
, capacity_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::clear
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef void ( ::SireBase::ChunkedVector< double, 100 >::*clear_function_type )( ) ;
clear_function_type clear_function_value( &::SireBase::ChunkedVector< double, 100 >::clear );
ChunkedVector_double__exposer.def(
"clear"
, clear_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::constBegin
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 >::const_iterator ( ::SireBase::ChunkedVector< double, 100 >::*constBegin_function_type )( ) const;
constBegin_function_type constBegin_function_value( &::SireBase::ChunkedVector< double, 100 >::constBegin );
ChunkedVector_double__exposer.def(
"constBegin"
, constBegin_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::constEnd
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 >::const_iterator ( ::SireBase::ChunkedVector< double, 100 >::*constEnd_function_type )( ) const;
constEnd_function_type constEnd_function_value( &::SireBase::ChunkedVector< double, 100 >::constEnd );
ChunkedVector_double__exposer.def(
"constEnd"
, constEnd_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::count
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef int ( ::SireBase::ChunkedVector< double, 100 >::*count_function_type )( ) const;
count_function_type count_function_value( &::SireBase::ChunkedVector< double, 100 >::count );
ChunkedVector_double__exposer.def(
"count"
, count_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::count
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef int ( ::SireBase::ChunkedVector< double, 100 >::*count_function_type )( double const & ) const;
count_function_type count_function_value( &::SireBase::ChunkedVector< double, 100 >::count );
ChunkedVector_double__exposer.def(
"count"
, count_function_value
, ( bp::arg("value") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::end
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 >::iterator ( ::SireBase::ChunkedVector< double, 100 >::*end_function_type )( ) ;
end_function_type end_function_value( &::SireBase::ChunkedVector< double, 100 >::end );
ChunkedVector_double__exposer.def(
"end"
, end_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::end
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 >::const_iterator ( ::SireBase::ChunkedVector< double, 100 >::*end_function_type )( ) const;
end_function_type end_function_value( &::SireBase::ChunkedVector< double, 100 >::end );
ChunkedVector_double__exposer.def(
"end"
, end_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::fromList
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 > ( *fromList_function_type )( ::QList< double > const & );
fromList_function_type fromList_function_value( &::SireBase::ChunkedVector< double, 100 >::fromList );
ChunkedVector_double__exposer.def(
"fromList"
, fromList_function_value
, ( bp::arg("list") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::fromStdVector
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 > ( *fromStdVector_function_type )( ::std::vector< double > const & );
fromStdVector_function_type fromStdVector_function_value( &::SireBase::ChunkedVector< double, 100 >::fromStdVector );
ChunkedVector_double__exposer.def(
"fromStdVector"
, fromStdVector_function_value
, ( bp::arg("vector") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::fromVector
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 > ( *fromVector_function_type )( ::QVector< double > const & );
fromVector_function_type fromVector_function_value( &::SireBase::ChunkedVector< double, 100 >::fromVector );
ChunkedVector_double__exposer.def(
"fromVector"
, fromVector_function_value
, ( bp::arg("vector") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::isEmpty
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef bool ( ::SireBase::ChunkedVector< double, 100 >::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireBase::ChunkedVector< double, 100 >::isEmpty );
ChunkedVector_double__exposer.def(
"isEmpty"
, isEmpty_function_value );
}
ChunkedVector_double__exposer.def( bp::self != bp::self );
{ //::SireBase::ChunkedVector< double, 100 >::operator=
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 > & ( ::SireBase::ChunkedVector< double, 100 >::*assign_function_type )( ::SireBase::ChunkedVector< double, 100 > const & ) ;
assign_function_type assign_function_value( &::SireBase::ChunkedVector< double, 100 >::operator= );
ChunkedVector_double__exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
ChunkedVector_double__exposer.def( bp::self == bp::self );
{ //::SireBase::ChunkedVector< double, 100 >::operator[]
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef double & ( ::SireBase::ChunkedVector< double, 100 >::*__getitem___function_type )( int ) ;
__getitem___function_type __getitem___function_value( &::SireBase::ChunkedVector< double, 100 >::operator[] );
ChunkedVector_double__exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_non_const_reference >() );
}
{ //::SireBase::ChunkedVector< double, 100 >::operator[]
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef double const & ( ::SireBase::ChunkedVector< double, 100 >::*__getitem___function_type )( int ) const;
__getitem___function_type __getitem___function_value( &::SireBase::ChunkedVector< double, 100 >::operator[] );
ChunkedVector_double__exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireBase::ChunkedVector< double, 100 >::remove
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef void ( ::SireBase::ChunkedVector< double, 100 >::*remove_function_type )( int ) ;
remove_function_type remove_function_value( &::SireBase::ChunkedVector< double, 100 >::remove );
ChunkedVector_double__exposer.def(
"remove"
, remove_function_value
, ( bp::arg("i") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::remove
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef void ( ::SireBase::ChunkedVector< double, 100 >::*remove_function_type )( int,int ) ;
remove_function_type remove_function_value( &::SireBase::ChunkedVector< double, 100 >::remove );
ChunkedVector_double__exposer.def(
"remove"
, remove_function_value
, ( bp::arg("i"), bp::arg("count") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::reserve
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef void ( ::SireBase::ChunkedVector< double, 100 >::*reserve_function_type )( int ) ;
reserve_function_type reserve_function_value( &::SireBase::ChunkedVector< double, 100 >::reserve );
ChunkedVector_double__exposer.def(
"reserve"
, reserve_function_value
, ( bp::arg("count") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::resize
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef void ( ::SireBase::ChunkedVector< double, 100 >::*resize_function_type )( int ) ;
resize_function_type resize_function_value( &::SireBase::ChunkedVector< double, 100 >::resize );
ChunkedVector_double__exposer.def(
"resize"
, resize_function_value
, ( bp::arg("count") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::size
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef int ( ::SireBase::ChunkedVector< double, 100 >::*size_function_type )( ) const;
size_function_type size_function_value( &::SireBase::ChunkedVector< double, 100 >::size );
ChunkedVector_double__exposer.def(
"size"
, size_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::squeeze
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef void ( ::SireBase::ChunkedVector< double, 100 >::*squeeze_function_type )( ) ;
squeeze_function_type squeeze_function_value( &::SireBase::ChunkedVector< double, 100 >::squeeze );
ChunkedVector_double__exposer.def(
"squeeze"
, squeeze_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::toList
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::QList< double > ( ::SireBase::ChunkedVector< double, 100 >::*toList_function_type )( ) const;
toList_function_type toList_function_value( &::SireBase::ChunkedVector< double, 100 >::toList );
ChunkedVector_double__exposer.def(
"toList"
, toList_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::toStdVector
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::std::vector< double > ( ::SireBase::ChunkedVector< double, 100 >::*toStdVector_function_type )( ) const;
toStdVector_function_type toStdVector_function_value( &::SireBase::ChunkedVector< double, 100 >::toStdVector );
ChunkedVector_double__exposer.def(
"toStdVector"
, toStdVector_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::toVector
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::QVector< double > ( ::SireBase::ChunkedVector< double, 100 >::*toVector_function_type )( ) const;
toVector_function_type toVector_function_value( &::SireBase::ChunkedVector< double, 100 >::toVector );
ChunkedVector_double__exposer.def(
"toVector"
, toVector_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::value
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef double ( ::SireBase::ChunkedVector< double, 100 >::*value_function_type )( int ) const;
value_function_type value_function_value( &::SireBase::ChunkedVector< double, 100 >::value );
ChunkedVector_double__exposer.def(
"value"
, value_function_value
, ( bp::arg("i") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::value
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef double ( ::SireBase::ChunkedVector< double, 100 >::*value_function_type )( int,double const & ) const;
value_function_type value_function_value( &::SireBase::ChunkedVector< double, 100 >::value );
ChunkedVector_double__exposer.def(
"value"
, value_function_value
, ( bp::arg("i"), bp::arg("default_value") ) );
}
ChunkedVector_double__exposer.staticmethod( "fromList" );
ChunkedVector_double__exposer.staticmethod( "fromStdVector" );
ChunkedVector_double__exposer.staticmethod( "fromVector" );
ChunkedVector_double__exposer.def( "__copy__", &__copy__);
ChunkedVector_double__exposer.def( "__deepcopy__", &__copy__);
ChunkedVector_double__exposer.def( "clone", &__copy__);
ChunkedVector_double__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::ChunkedVector<double, 100> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ChunkedVector_double__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::ChunkedVector<double, 100> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ChunkedVector_double__exposer.def( "__str__", &pvt_get_name);
ChunkedVector_double__exposer.def( "__repr__", &pvt_get_name);
ChunkedVector_double__exposer.def( "__len__", &__len_size< ::SireBase::ChunkedVector<double, 100> > );
}
}
void register_PropertyList_class(){
{ //::SireBase::PropertyList
typedef bp::class_< SireBase::PropertyList, bp::bases< SireBase::Property > > PropertyList_exposer_t;
PropertyList_exposer_t PropertyList_exposer = PropertyList_exposer_t( "PropertyList", bp::init< >() );
bp::scope PropertyList_scope( PropertyList_exposer );
PropertyList_exposer.def( bp::init< QList< SireBase::PropPtr< SireBase::Property > > const & >(( bp::arg("props") )) );
PropertyList_exposer.def( bp::init< SireBase::PropertyList const & >(( bp::arg("other") )) );
{ //::SireBase::PropertyList::append
typedef void ( ::SireBase::PropertyList::*append_function_type )( ::SireBase::Property const & ) ;
append_function_type append_function_value( &::SireBase::PropertyList::append );
PropertyList_exposer.def(
"append"
, append_function_value
, ( bp::arg("property") ) );
}
{ //::SireBase::PropertyList::append
typedef void ( ::SireBase::PropertyList::*append_function_type )( ::QList< SireBase::PropPtr< SireBase::Property > > const & ) ;
append_function_type append_function_value( &::SireBase::PropertyList::append );
PropertyList_exposer.def(
"append"
, append_function_value
, ( bp::arg("props") ) );
}
{ //::SireBase::PropertyList::array
typedef ::QList< SireBase::PropPtr< SireBase::Property > > ( ::SireBase::PropertyList::*array_function_type )( ) const;
array_function_type array_function_value( &::SireBase::PropertyList::array );
PropertyList_exposer.def(
"array"
, array_function_value );
}
{ //::SireBase::PropertyList::at
typedef ::SireBase::Property const & ( ::SireBase::PropertyList::*at_function_type )( int ) const;
at_function_type at_function_value( &::SireBase::PropertyList::at );
PropertyList_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireBase::PropertyList::clear
typedef void ( ::SireBase::PropertyList::*clear_function_type )( ) ;
clear_function_type clear_function_value( &::SireBase::PropertyList::clear );
PropertyList_exposer.def(
"clear"
, clear_function_value );
}
{ //::SireBase::PropertyList::count
typedef int ( ::SireBase::PropertyList::*count_function_type )( ) const;
count_function_type count_function_value( &::SireBase::PropertyList::count );
PropertyList_exposer.def(
"count"
, count_function_value );
}
{ //::SireBase::PropertyList::empty
typedef bool ( ::SireBase::PropertyList::*empty_function_type )( ) const;
empty_function_type empty_function_value( &::SireBase::PropertyList::empty );
PropertyList_exposer.def(
"empty"
, empty_function_value );
}
{ //::SireBase::PropertyList::insert
typedef void ( ::SireBase::PropertyList::*insert_function_type )( int,::SireBase::Property const & ) ;
insert_function_type insert_function_value( &::SireBase::PropertyList::insert );
PropertyList_exposer.def(
"insert"
, insert_function_value
, ( bp::arg("i"), bp::arg("value") ) );
}
{ //::SireBase::PropertyList::isEmpty
typedef bool ( ::SireBase::PropertyList::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireBase::PropertyList::isEmpty );
PropertyList_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireBase::PropertyList::mid
typedef ::SireBase::PropertyList ( ::SireBase::PropertyList::*mid_function_type )( int,int ) const;
mid_function_type mid_function_value( &::SireBase::PropertyList::mid );
PropertyList_exposer.def(
"mid"
, mid_function_value
, ( bp::arg("pos"), bp::arg("length")=(int)(-0x00000000000000001) ) );
}
{ //::SireBase::PropertyList::move
typedef void ( ::SireBase::PropertyList::*move_function_type )( int,int ) ;
move_function_type move_function_value( &::SireBase::PropertyList::move );
PropertyList_exposer.def(
"move"
, move_function_value
, ( bp::arg("from"), bp::arg("to") ) );
}
PropertyList_exposer.def( bp::self != bp::self );
PropertyList_exposer.def( bp::self + bp::self );
{ //::SireBase::PropertyList::operator=
typedef ::SireBase::PropertyList & ( ::SireBase::PropertyList::*assign_function_type )( ::SireBase::PropertyList const & ) ;
assign_function_type assign_function_value( &::SireBase::PropertyList::operator= );
PropertyList_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
PropertyList_exposer.def( bp::self == bp::self );
{ //::SireBase::PropertyList::operator[]
typedef ::SireBase::Property const & ( ::SireBase::PropertyList::*__getitem___function_type )( int ) const;
__getitem___function_type __getitem___function_value( &::SireBase::PropertyList::operator[] );
PropertyList_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireBase::PropertyList::pop_back
typedef void ( ::SireBase::PropertyList::*pop_back_function_type )( ) ;
pop_back_function_type pop_back_function_value( &::SireBase::PropertyList::pop_back );
PropertyList_exposer.def(
"pop_back"
, pop_back_function_value );
}
{ //::SireBase::PropertyList::pop_front
typedef void ( ::SireBase::PropertyList::*pop_front_function_type )( ) ;
pop_front_function_type pop_front_function_value( &::SireBase::PropertyList::pop_front );
PropertyList_exposer.def(
"pop_front"
, pop_front_function_value );
}
{ //::SireBase::PropertyList::prepend
typedef void ( ::SireBase::PropertyList::*prepend_function_type )( ::SireBase::Property const & ) ;
prepend_function_type prepend_function_value( &::SireBase::PropertyList::prepend );
PropertyList_exposer.def(
"prepend"
, prepend_function_value
, ( bp::arg("value") ) );
}
{ //::SireBase::PropertyList::push_back
typedef void ( ::SireBase::PropertyList::*push_back_function_type )( ::SireBase::Property const & ) ;
push_back_function_type push_back_function_value( &::SireBase::PropertyList::push_back );
PropertyList_exposer.def(
"push_back"
, push_back_function_value
, ( bp::arg("value") ) );
}
{ //::SireBase::PropertyList::push_front
typedef void ( ::SireBase::PropertyList::*push_front_function_type )( ::SireBase::Property const & ) ;
push_front_function_type push_front_function_value( &::SireBase::PropertyList::push_front );
PropertyList_exposer.def(
"push_front"
, push_front_function_value
, ( bp::arg("value") ) );
}
{ //::SireBase::PropertyList::removeAt
typedef void ( ::SireBase::PropertyList::*removeAt_function_type )( int ) ;
removeAt_function_type removeAt_function_value( &::SireBase::PropertyList::removeAt );
PropertyList_exposer.def(
"removeAt"
, removeAt_function_value
, ( bp::arg("i") ) );
}
{ //::SireBase::PropertyList::removeFirst
typedef void ( ::SireBase::PropertyList::*removeFirst_function_type )( ) ;
removeFirst_function_type removeFirst_function_value( &::SireBase::PropertyList::removeFirst );
PropertyList_exposer.def(
"removeFirst"
, removeFirst_function_value );
}
{ //::SireBase::PropertyList::removeLast
typedef void ( ::SireBase::PropertyList::*removeLast_function_type )( ) ;
removeLast_function_type removeLast_function_value( &::SireBase::PropertyList::removeLast );
PropertyList_exposer.def(
"removeLast"
, removeLast_function_value );
}
{ //::SireBase::PropertyList::replace
typedef void ( ::SireBase::PropertyList::*replace_function_type )( int,::SireBase::Property const & ) ;
replace_function_type replace_function_value( &::SireBase::PropertyList::replace );
PropertyList_exposer.def(
"replace"
, replace_function_value
, ( bp::arg("i"), bp::arg("value") ) );
}
{ //::SireBase::PropertyList::size
typedef int ( ::SireBase::PropertyList::*size_function_type )( ) const;
size_function_type size_function_value( &::SireBase::PropertyList::size );
PropertyList_exposer.def(
"size"
, size_function_value );
}
{ //::SireBase::PropertyList::swap
typedef void ( ::SireBase::PropertyList::*swap_function_type )( ::SireBase::PropertyList & ) ;
swap_function_type swap_function_value( &::SireBase::PropertyList::swap );
PropertyList_exposer.def(
"swap"
, swap_function_value
, ( bp::arg("other") ) );
}
{ //::SireBase::PropertyList::swap
typedef void ( ::SireBase::PropertyList::*swap_function_type )( int,int ) ;
swap_function_type swap_function_value( &::SireBase::PropertyList::swap );
PropertyList_exposer.def(
"swap"
, swap_function_value
, ( bp::arg("i"), bp::arg("j") ) );
}
{ //::SireBase::PropertyList::takeAt
typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*takeAt_function_type )( int ) ;
takeAt_function_type takeAt_function_value( &::SireBase::PropertyList::takeAt );
PropertyList_exposer.def(
"takeAt"
, takeAt_function_value
, ( bp::arg("i") ) );
}
{ //::SireBase::PropertyList::takeFirst
typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*takeFirst_function_type )( ) ;
takeFirst_function_type takeFirst_function_value( &::SireBase::PropertyList::takeFirst );
PropertyList_exposer.def(
"takeFirst"
, takeFirst_function_value );
}
{ //::SireBase::PropertyList::takeLast
typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*takeLast_function_type )( ) ;
takeLast_function_type takeLast_function_value( &::SireBase::PropertyList::takeLast );
PropertyList_exposer.def(
"takeLast"
, takeLast_function_value );
}
{ //::SireBase::PropertyList::toList
typedef ::QList< SireBase::PropPtr< SireBase::Property > > ( ::SireBase::PropertyList::*toList_function_type )( ) const;
toList_function_type toList_function_value( &::SireBase::PropertyList::toList );
PropertyList_exposer.def(
"toList"
, toList_function_value );
}
{ //::SireBase::PropertyList::toString
typedef ::QString ( ::SireBase::PropertyList::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireBase::PropertyList::toString );
PropertyList_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireBase::PropertyList::toVector
typedef ::QVector< SireBase::PropPtr< SireBase::Property > > ( ::SireBase::PropertyList::*toVector_function_type )( ) const;
toVector_function_type toVector_function_value( &::SireBase::PropertyList::toVector );
PropertyList_exposer.def(
"toVector"
, toVector_function_value );
}
{ //::SireBase::PropertyList::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireBase::PropertyList::typeName );
PropertyList_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireBase::PropertyList::value
typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*value_function_type )( int ) const;
value_function_type value_function_value( &::SireBase::PropertyList::value );
PropertyList_exposer.def(
"value"
, value_function_value
, ( bp::arg("i") ) );
}
{ //::SireBase::PropertyList::value
typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*value_function_type )( int,::SireBase::Property const & ) const;
value_function_type value_function_value( &::SireBase::PropertyList::value );
PropertyList_exposer.def(
"value"
, value_function_value
, ( bp::arg("i"), bp::arg("default_value") ) );
}
PropertyList_exposer.staticmethod( "typeName" );
PropertyList_exposer.def( "__copy__", &__copy__);
PropertyList_exposer.def( "__deepcopy__", &__copy__);
PropertyList_exposer.def( "clone", &__copy__);
PropertyList_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::PropertyList >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
PropertyList_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::PropertyList >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
PropertyList_exposer.def( "__str__", &__str__< ::SireBase::PropertyList > );
PropertyList_exposer.def( "__repr__", &__str__< ::SireBase::PropertyList > );
PropertyList_exposer.def( "__len__", &__len_size< ::SireBase::PropertyList > );
}
}
void register_TI_class(){
{ //::SireAnalysis::TI
typedef bp::class_< SireAnalysis::TI, bp::bases< SireBase::Property > > TI_exposer_t;
TI_exposer_t TI_exposer = TI_exposer_t( "TI", bp::init< >() );
bp::scope TI_scope( TI_exposer );
TI_exposer.def( bp::init< SireAnalysis::Gradients const & >(( bp::arg("gradients") )) );
TI_exposer.def( bp::init< QList< SireAnalysis::Gradients > const & >(( bp::arg("gradients") )) );
TI_exposer.def( bp::init< SireAnalysis::TI const & >(( bp::arg("other") )) );
{ //::SireAnalysis::TI::add
typedef void ( ::SireAnalysis::TI::*add_function_type )( ::QMap< double, SireMaths::AverageAndStddev > const & ) ;
add_function_type add_function_value( &::SireAnalysis::TI::add );
TI_exposer.def(
"add"
, add_function_value
, ( bp::arg("gradients") ) );
}
{ //::SireAnalysis::TI::add
typedef void ( ::SireAnalysis::TI::*add_function_type )( ::QMap< double, SireMaths::FreeEnergyAverage > const & ) ;
add_function_type add_function_value( &::SireAnalysis::TI::add );
TI_exposer.def(
"add"
, add_function_value
, ( bp::arg("gradients") ) );
}
{ //::SireAnalysis::TI::add
typedef void ( ::SireAnalysis::TI::*add_function_type )( ::QMap< double, SireMaths::FreeEnergyAverage > const &,double ) ;
add_function_type add_function_value( &::SireAnalysis::TI::add );
TI_exposer.def(
"add"
, add_function_value
, ( bp::arg("gradients"), bp::arg("delta_lambda") ) );
}
{ //::SireAnalysis::TI::add
typedef void ( ::SireAnalysis::TI::*add_function_type )( ::QMap< double, SireMaths::FreeEnergyAverage > const &,::QMap< double, SireMaths::FreeEnergyAverage > const &,double ) ;
add_function_type add_function_value( &::SireAnalysis::TI::add );
TI_exposer.def(
"add"
, add_function_value
, ( bp::arg("forwards"), bp::arg("backwards"), bp::arg("delta_lambda") ) );
}
{ //::SireAnalysis::TI::add
typedef void ( ::SireAnalysis::TI::*add_function_type )( ::SireAnalysis::Gradients const & ) ;
add_function_type add_function_value( &::SireAnalysis::TI::add );
TI_exposer.def(
"add"
, add_function_value
, ( bp::arg("gradients") ) );
}
{ //::SireAnalysis::TI::at
typedef ::SireAnalysis::Gradients ( ::SireAnalysis::TI::*at_function_type )( int ) const;
at_function_type at_function_value( &::SireAnalysis::TI::at );
TI_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") ) );
}
{ //::SireAnalysis::TI::clear
typedef void ( ::SireAnalysis::TI::*clear_function_type )( ) ;
clear_function_type clear_function_value( &::SireAnalysis::TI::clear );
TI_exposer.def(
"clear"
, clear_function_value );
}
{ //::SireAnalysis::TI::count
typedef int ( ::SireAnalysis::TI::*count_function_type )( ) const;
count_function_type count_function_value( &::SireAnalysis::TI::count );
TI_exposer.def(
"count"
, count_function_value );
}
{ //::SireAnalysis::TI::gradients
typedef ::QList< SireAnalysis::Gradients > ( ::SireAnalysis::TI::*gradients_function_type )( ) const;
gradients_function_type gradients_function_value( &::SireAnalysis::TI::gradients );
TI_exposer.def(
"gradients"
, gradients_function_value );
}
{ //::SireAnalysis::TI::lambdaValues
typedef ::QList< double > ( ::SireAnalysis::TI::*lambdaValues_function_type )( ) const;
lambdaValues_function_type lambdaValues_function_value( &::SireAnalysis::TI::lambdaValues );
TI_exposer.def(
"lambdaValues"
, lambdaValues_function_value );
}
{ //::SireAnalysis::TI::merge
typedef ::SireAnalysis::Gradients ( ::SireAnalysis::TI::*merge_function_type )( int,int ) const;
merge_function_type merge_function_value( &::SireAnalysis::TI::merge );
TI_exposer.def(
"merge"
, merge_function_value
, ( bp::arg("start"), bp::arg("end") ) );
}
{ //::SireAnalysis::TI::merge
typedef ::SireAnalysis::Gradients ( ::SireAnalysis::TI::*merge_function_type )( ::QList< int > ) const;
merge_function_type merge_function_value( &::SireAnalysis::TI::merge );
TI_exposer.def(
"merge"
, merge_function_value
, ( bp::arg("indicies") ) );
}
{ //::SireAnalysis::TI::nIterations
typedef int ( ::SireAnalysis::TI::*nIterations_function_type )( ) const;
nIterations_function_type nIterations_function_value( &::SireAnalysis::TI::nIterations );
TI_exposer.def(
"nIterations"
, nIterations_function_value );
}
{ //::SireAnalysis::TI::nLambdaValues
typedef int ( ::SireAnalysis::TI::*nLambdaValues_function_type )( ) const;
nLambdaValues_function_type nLambdaValues_function_value( &::SireAnalysis::TI::nLambdaValues );
TI_exposer.def(
"nLambdaValues"
, nLambdaValues_function_value );
}
{ //::SireAnalysis::TI::nSamples
typedef ::qint64 ( ::SireAnalysis::TI::*nSamples_function_type )( ) const;
nSamples_function_type nSamples_function_value( &::SireAnalysis::TI::nSamples );
TI_exposer.def(
"nSamples"
, nSamples_function_value );
}
TI_exposer.def( bp::self != bp::self );
{ //::SireAnalysis::TI::operator=
typedef ::SireAnalysis::TI & ( ::SireAnalysis::TI::*assign_function_type )( ::SireAnalysis::TI const & ) ;
assign_function_type assign_function_value( &::SireAnalysis::TI::operator= );
TI_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
TI_exposer.def( bp::self == bp::self );
{ //::SireAnalysis::TI::operator[]
typedef ::SireAnalysis::Gradients ( ::SireAnalysis::TI::*__getitem___function_type )( int ) const;
__getitem___function_type __getitem___function_value( &::SireAnalysis::TI::operator[] );
TI_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") ) );
}
{ //::SireAnalysis::TI::removeAt
typedef void ( ::SireAnalysis::TI::*removeAt_function_type )( int ) ;
removeAt_function_type removeAt_function_value( &::SireAnalysis::TI::removeAt );
TI_exposer.def(
"removeAt"
, removeAt_function_value
, ( bp::arg("i") ) );
}
{ //::SireAnalysis::TI::removeRange
typedef void ( ::SireAnalysis::TI::*removeRange_function_type )( int,int ) ;
removeRange_function_type removeRange_function_value( &::SireAnalysis::TI::removeRange );
TI_exposer.def(
"removeRange"
, removeRange_function_value
, ( bp::arg("start"), bp::arg("end") ) );
}
{ //::SireAnalysis::TI::rollingAverage
typedef ::QList< SireAnalysis::Gradients > ( ::SireAnalysis::TI::*rollingAverage_function_type )( int ) const;
rollingAverage_function_type rollingAverage_function_value( &::SireAnalysis::TI::rollingAverage );
TI_exposer.def(
"rollingAverage"
, rollingAverage_function_value
, ( bp::arg("niterations") ) );
}
{ //::SireAnalysis::TI::set
typedef void ( ::SireAnalysis::TI::*set_function_type )( int,::QMap< double, SireMaths::AverageAndStddev > const & ) ;
set_function_type set_function_value( &::SireAnalysis::TI::set );
TI_exposer.def(
"set"
, set_function_value
, ( bp::arg("i"), bp::arg("gradients") ) );
}
{ //::SireAnalysis::TI::set
typedef void ( ::SireAnalysis::TI::*set_function_type )( int,::QMap< double, SireMaths::FreeEnergyAverage > const & ) ;
set_function_type set_function_value( &::SireAnalysis::TI::set );
TI_exposer.def(
"set"
, set_function_value
, ( bp::arg("i"), bp::arg("gradients") ) );
}
{ //::SireAnalysis::TI::set
typedef void ( ::SireAnalysis::TI::*set_function_type )( int,::QMap< double, SireMaths::FreeEnergyAverage > const &,double ) ;
set_function_type set_function_value( &::SireAnalysis::TI::set );
TI_exposer.def(
"set"
, set_function_value
, ( bp::arg("i"), bp::arg("gradients"), bp::arg("delta_lambda") ) );
}
{ //::SireAnalysis::TI::set
typedef void ( ::SireAnalysis::TI::*set_function_type )( int,::QMap< double, SireMaths::FreeEnergyAverage > const &,::QMap< double, SireMaths::FreeEnergyAverage > const &,double ) ;
set_function_type set_function_value( &::SireAnalysis::TI::set );
TI_exposer.def(
"set"
, set_function_value
, ( bp::arg("i"), bp::arg("forwards"), bp::arg("backwards"), bp::arg("delta_lambda") ) );
}
{ //::SireAnalysis::TI::set
typedef void ( ::SireAnalysis::TI::*set_function_type )( int,::SireAnalysis::Gradients const & ) ;
set_function_type set_function_value( &::SireAnalysis::TI::set );
TI_exposer.def(
"set"
, set_function_value
, ( bp::arg("i"), bp::arg("gradients") ) );
}
{ //::SireAnalysis::TI::size
typedef int ( ::SireAnalysis::TI::*size_function_type )( ) const;
size_function_type size_function_value( &::SireAnalysis::TI::size );
TI_exposer.def(
"size"
, size_function_value );
}
{ //::SireAnalysis::TI::toString
typedef ::QString ( ::SireAnalysis::TI::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireAnalysis::TI::toString );
TI_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireAnalysis::TI::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireAnalysis::TI::typeName );
TI_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireAnalysis::TI::what
typedef char const * ( ::SireAnalysis::TI::*what_function_type )( ) const;
what_function_type what_function_value( &::SireAnalysis::TI::what );
TI_exposer.def(
"what"
, what_function_value );
}
TI_exposer.staticmethod( "typeName" );
TI_exposer.def( "__copy__", &__copy__);
TI_exposer.def( "__deepcopy__", &__copy__);
TI_exposer.def( "clone", &__copy__);
TI_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireAnalysis::TI >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
TI_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireAnalysis::TI >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
TI_exposer.def( "__str__", &__str__< ::SireAnalysis::TI > );
TI_exposer.def( "__repr__", &__str__< ::SireAnalysis::TI > );
TI_exposer.def( "__len__", &__len_size< ::SireAnalysis::TI > );
}
}
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 > );
}
}