void register_PropertyList_class(){
{ //::SireBase::PropertyList
typedef bp::class_< SireBase::PropertyList, bp::bases< SireBase::Property > > PropertyList_exposer_t;
PropertyList_exposer_t PropertyList_exposer = PropertyList_exposer_t( "PropertyList", bp::init< >() );
bp::scope PropertyList_scope( PropertyList_exposer );
PropertyList_exposer.def( bp::init< QList< SireBase::PropPtr< SireBase::Property > > const & >(( bp::arg("props") )) );
PropertyList_exposer.def( bp::init< SireBase::PropertyList const & >(( bp::arg("other") )) );
{ //::SireBase::PropertyList::append
typedef void ( ::SireBase::PropertyList::*append_function_type )( ::SireBase::Property const & ) ;
append_function_type append_function_value( &::SireBase::PropertyList::append );
PropertyList_exposer.def(
"append"
, append_function_value
, ( bp::arg("property") ) );
}
{ //::SireBase::PropertyList::append
typedef void ( ::SireBase::PropertyList::*append_function_type )( ::QList< SireBase::PropPtr< SireBase::Property > > const & ) ;
append_function_type append_function_value( &::SireBase::PropertyList::append );
PropertyList_exposer.def(
"append"
, append_function_value
, ( bp::arg("props") ) );
}
{ //::SireBase::PropertyList::array
typedef ::QList< SireBase::PropPtr< SireBase::Property > > ( ::SireBase::PropertyList::*array_function_type )( ) const;
array_function_type array_function_value( &::SireBase::PropertyList::array );
PropertyList_exposer.def(
"array"
, array_function_value );
}
{ //::SireBase::PropertyList::at
typedef ::SireBase::Property const & ( ::SireBase::PropertyList::*at_function_type )( int ) const;
at_function_type at_function_value( &::SireBase::PropertyList::at );
PropertyList_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireBase::PropertyList::clear
typedef void ( ::SireBase::PropertyList::*clear_function_type )( ) ;
clear_function_type clear_function_value( &::SireBase::PropertyList::clear );
PropertyList_exposer.def(
"clear"
, clear_function_value );
}
{ //::SireBase::PropertyList::count
typedef int ( ::SireBase::PropertyList::*count_function_type )( ) const;
count_function_type count_function_value( &::SireBase::PropertyList::count );
PropertyList_exposer.def(
"count"
, count_function_value );
}
{ //::SireBase::PropertyList::empty
typedef bool ( ::SireBase::PropertyList::*empty_function_type )( ) const;
empty_function_type empty_function_value( &::SireBase::PropertyList::empty );
PropertyList_exposer.def(
"empty"
, empty_function_value );
}
{ //::SireBase::PropertyList::insert
typedef void ( ::SireBase::PropertyList::*insert_function_type )( int,::SireBase::Property const & ) ;
insert_function_type insert_function_value( &::SireBase::PropertyList::insert );
PropertyList_exposer.def(
"insert"
, insert_function_value
, ( bp::arg("i"), bp::arg("value") ) );
}
{ //::SireBase::PropertyList::isEmpty
typedef bool ( ::SireBase::PropertyList::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireBase::PropertyList::isEmpty );
PropertyList_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireBase::PropertyList::mid
typedef ::SireBase::PropertyList ( ::SireBase::PropertyList::*mid_function_type )( int,int ) const;
mid_function_type mid_function_value( &::SireBase::PropertyList::mid );
PropertyList_exposer.def(
"mid"
, mid_function_value
, ( bp::arg("pos"), bp::arg("length")=(int)(-0x00000000000000001) ) );
}
{ //::SireBase::PropertyList::move
typedef void ( ::SireBase::PropertyList::*move_function_type )( int,int ) ;
move_function_type move_function_value( &::SireBase::PropertyList::move );
PropertyList_exposer.def(
"move"
, move_function_value
, ( bp::arg("from"), bp::arg("to") ) );
}
PropertyList_exposer.def( bp::self != bp::self );
PropertyList_exposer.def( bp::self + bp::self );
{ //::SireBase::PropertyList::operator=
typedef ::SireBase::PropertyList & ( ::SireBase::PropertyList::*assign_function_type )( ::SireBase::PropertyList const & ) ;
assign_function_type assign_function_value( &::SireBase::PropertyList::operator= );
PropertyList_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
PropertyList_exposer.def( bp::self == bp::self );
{ //::SireBase::PropertyList::operator[]
typedef ::SireBase::Property const & ( ::SireBase::PropertyList::*__getitem___function_type )( int ) const;
__getitem___function_type __getitem___function_value( &::SireBase::PropertyList::operator[] );
PropertyList_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireBase::PropertyList::pop_back
typedef void ( ::SireBase::PropertyList::*pop_back_function_type )( ) ;
pop_back_function_type pop_back_function_value( &::SireBase::PropertyList::pop_back );
PropertyList_exposer.def(
"pop_back"
, pop_back_function_value );
}
{ //::SireBase::PropertyList::pop_front
typedef void ( ::SireBase::PropertyList::*pop_front_function_type )( ) ;
pop_front_function_type pop_front_function_value( &::SireBase::PropertyList::pop_front );
PropertyList_exposer.def(
"pop_front"
, pop_front_function_value );
}
{ //::SireBase::PropertyList::prepend
typedef void ( ::SireBase::PropertyList::*prepend_function_type )( ::SireBase::Property const & ) ;
prepend_function_type prepend_function_value( &::SireBase::PropertyList::prepend );
PropertyList_exposer.def(
"prepend"
, prepend_function_value
, ( bp::arg("value") ) );
}
{ //::SireBase::PropertyList::push_back
typedef void ( ::SireBase::PropertyList::*push_back_function_type )( ::SireBase::Property const & ) ;
push_back_function_type push_back_function_value( &::SireBase::PropertyList::push_back );
PropertyList_exposer.def(
"push_back"
, push_back_function_value
, ( bp::arg("value") ) );
}
{ //::SireBase::PropertyList::push_front
typedef void ( ::SireBase::PropertyList::*push_front_function_type )( ::SireBase::Property const & ) ;
push_front_function_type push_front_function_value( &::SireBase::PropertyList::push_front );
PropertyList_exposer.def(
"push_front"
, push_front_function_value
, ( bp::arg("value") ) );
}
{ //::SireBase::PropertyList::removeAt
typedef void ( ::SireBase::PropertyList::*removeAt_function_type )( int ) ;
removeAt_function_type removeAt_function_value( &::SireBase::PropertyList::removeAt );
PropertyList_exposer.def(
"removeAt"
, removeAt_function_value
, ( bp::arg("i") ) );
}
{ //::SireBase::PropertyList::removeFirst
typedef void ( ::SireBase::PropertyList::*removeFirst_function_type )( ) ;
removeFirst_function_type removeFirst_function_value( &::SireBase::PropertyList::removeFirst );
PropertyList_exposer.def(
"removeFirst"
, removeFirst_function_value );
}
{ //::SireBase::PropertyList::removeLast
typedef void ( ::SireBase::PropertyList::*removeLast_function_type )( ) ;
removeLast_function_type removeLast_function_value( &::SireBase::PropertyList::removeLast );
PropertyList_exposer.def(
"removeLast"
, removeLast_function_value );
}
{ //::SireBase::PropertyList::replace
typedef void ( ::SireBase::PropertyList::*replace_function_type )( int,::SireBase::Property const & ) ;
replace_function_type replace_function_value( &::SireBase::PropertyList::replace );
PropertyList_exposer.def(
"replace"
, replace_function_value
, ( bp::arg("i"), bp::arg("value") ) );
}
{ //::SireBase::PropertyList::size
typedef int ( ::SireBase::PropertyList::*size_function_type )( ) const;
size_function_type size_function_value( &::SireBase::PropertyList::size );
PropertyList_exposer.def(
"size"
, size_function_value );
}
{ //::SireBase::PropertyList::swap
typedef void ( ::SireBase::PropertyList::*swap_function_type )( ::SireBase::PropertyList & ) ;
swap_function_type swap_function_value( &::SireBase::PropertyList::swap );
PropertyList_exposer.def(
"swap"
, swap_function_value
, ( bp::arg("other") ) );
}
{ //::SireBase::PropertyList::swap
typedef void ( ::SireBase::PropertyList::*swap_function_type )( int,int ) ;
swap_function_type swap_function_value( &::SireBase::PropertyList::swap );
PropertyList_exposer.def(
"swap"
, swap_function_value
, ( bp::arg("i"), bp::arg("j") ) );
}
{ //::SireBase::PropertyList::takeAt
typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*takeAt_function_type )( int ) ;
takeAt_function_type takeAt_function_value( &::SireBase::PropertyList::takeAt );
PropertyList_exposer.def(
"takeAt"
, takeAt_function_value
, ( bp::arg("i") ) );
}
{ //::SireBase::PropertyList::takeFirst
typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*takeFirst_function_type )( ) ;
takeFirst_function_type takeFirst_function_value( &::SireBase::PropertyList::takeFirst );
PropertyList_exposer.def(
"takeFirst"
, takeFirst_function_value );
}
{ //::SireBase::PropertyList::takeLast
typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*takeLast_function_type )( ) ;
takeLast_function_type takeLast_function_value( &::SireBase::PropertyList::takeLast );
PropertyList_exposer.def(
"takeLast"
, takeLast_function_value );
}
{ //::SireBase::PropertyList::toList
typedef ::QList< SireBase::PropPtr< SireBase::Property > > ( ::SireBase::PropertyList::*toList_function_type )( ) const;
toList_function_type toList_function_value( &::SireBase::PropertyList::toList );
PropertyList_exposer.def(
"toList"
, toList_function_value );
}
{ //::SireBase::PropertyList::toString
typedef ::QString ( ::SireBase::PropertyList::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireBase::PropertyList::toString );
PropertyList_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireBase::PropertyList::toVector
typedef ::QVector< SireBase::PropPtr< SireBase::Property > > ( ::SireBase::PropertyList::*toVector_function_type )( ) const;
toVector_function_type toVector_function_value( &::SireBase::PropertyList::toVector );
PropertyList_exposer.def(
"toVector"
, toVector_function_value );
}
{ //::SireBase::PropertyList::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireBase::PropertyList::typeName );
PropertyList_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireBase::PropertyList::value
typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*value_function_type )( int ) const;
value_function_type value_function_value( &::SireBase::PropertyList::value );
PropertyList_exposer.def(
"value"
, value_function_value
, ( bp::arg("i") ) );
}
{ //::SireBase::PropertyList::value
typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*value_function_type )( int,::SireBase::Property const & ) const;
value_function_type value_function_value( &::SireBase::PropertyList::value );
PropertyList_exposer.def(
"value"
, value_function_value
, ( bp::arg("i"), bp::arg("default_value") ) );
}
PropertyList_exposer.staticmethod( "typeName" );
PropertyList_exposer.def( "__copy__", &__copy__);
PropertyList_exposer.def( "__deepcopy__", &__copy__);
PropertyList_exposer.def( "clone", &__copy__);
PropertyList_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::PropertyList >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
PropertyList_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::PropertyList >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
PropertyList_exposer.def( "__str__", &__str__< ::SireBase::PropertyList > );
PropertyList_exposer.def( "__repr__", &__str__< ::SireBase::PropertyList > );
PropertyList_exposer.def( "__len__", &__len_size< ::SireBase::PropertyList > );
}
}
void register_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_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 > );
}
}
