예제 #1
0
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 > );
    }

}
예제 #2
0
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 > );
    }

}
예제 #3
0
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 );
    }

}
예제 #4
0
파일: FEP.pypp.cpp 프로젝트: Steboss/Sire
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> > );
    }

}
예제 #6
0
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 > );
    }

}
예제 #7
0
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 > );
    }

}
예제 #8
0
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 > );
    }

}