void register_Number_class(){ { //::SireID::Number typedef bp::class_< SireID::Number, boost::noncopyable > Number_exposer_t; Number_exposer_t Number_exposer = Number_exposer_t( "Number", bp::no_init ); bp::scope Number_scope( Number_exposer ); { //::SireID::Number::hash typedef ::uint ( ::SireID::Number::*hash_function_type )( ) const; hash_function_type hash_function_value( &::SireID::Number::hash ); Number_exposer.def( "hash" , hash_function_value ); } { //::SireID::Number::isNull typedef bool ( ::SireID::Number::*isNull_function_type )( ) const; isNull_function_type isNull_function_value( &::SireID::Number::isNull ); Number_exposer.def( "isNull" , isNull_function_value ); } { //::SireID::Number::null typedef ::qint32 ( *null_function_type )( ); null_function_type null_function_value( &::SireID::Number::null ); Number_exposer.def( "null" , null_function_value ); } { //::SireID::Number::value typedef ::qint32 ( ::SireID::Number::*value_function_type )( ) const; value_function_type value_function_value( &::SireID::Number::value ); Number_exposer.def( "value" , value_function_value ); } Number_exposer.staticmethod( "null" ); Number_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireID::Number >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Number_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireID::Number >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Number_exposer.def( "__str__", &pvt_get_name); Number_exposer.def( "__repr__", &pvt_get_name); } }
void register_DoubleFunc_class(){ { //::SireCAS::DoubleFunc typedef bp::class_< SireCAS::DoubleFunc, bp::bases< SireCAS::ExBase >, boost::noncopyable > DoubleFunc_exposer_t; DoubleFunc_exposer_t DoubleFunc_exposer = DoubleFunc_exposer_t( "DoubleFunc", "Base class of all double-expression functions ( e.g. f(x(), y()) )\n\nAuthor: Christopher Woods\n", bp::no_init ); bp::scope DoubleFunc_scope( DoubleFunc_exposer ); { //::SireCAS::DoubleFunc::children typedef ::SireCAS::Expressions ( ::SireCAS::DoubleFunc::*children_function_type)( ) const; children_function_type children_function_value( &::SireCAS::DoubleFunc::children ); DoubleFunc_exposer.def( "children" , children_function_value , "Return the child expression of this function" ); } { //::SireCAS::DoubleFunc::conjugate typedef ::SireCAS::Expression ( ::SireCAS::DoubleFunc::*conjugate_function_type)( ) const; conjugate_function_type conjugate_function_value( &::SireCAS::DoubleFunc::conjugate ); DoubleFunc_exposer.def( "conjugate" , conjugate_function_value , "Return the conjugate of this function" ); } { //::SireCAS::DoubleFunc::differentiate typedef ::SireCAS::Expression ( ::SireCAS::DoubleFunc::*differentiate_function_type)( ::SireCAS::Symbol const & ) const; differentiate_function_type differentiate_function_value( &::SireCAS::DoubleFunc::differentiate ); DoubleFunc_exposer.def( "differentiate" , differentiate_function_value , ( bp::arg("symbol") ) , "Return the differential of this function with respect to symbol" ); } { //::SireCAS::DoubleFunc::expand typedef ::QList< SireCAS::Factor > ( ::SireCAS::DoubleFunc::*expand_function_type)( ::SireCAS::Symbol const & ) const; expand_function_type expand_function_value( &::SireCAS::DoubleFunc::expand ); DoubleFunc_exposer.def( "expand" , expand_function_value , ( bp::arg("symbol") ) , "" ); } { //::SireCAS::DoubleFunc::functions typedef ::SireCAS::Functions ( ::SireCAS::DoubleFunc::*functions_function_type)( ) const; functions_function_type functions_function_value( &::SireCAS::DoubleFunc::functions ); DoubleFunc_exposer.def( "functions" , functions_function_value , "Return the functions used in this function" ); } { //::SireCAS::DoubleFunc::hash typedef ::uint ( ::SireCAS::DoubleFunc::*hash_function_type)( ) const; hash_function_type hash_function_value( &::SireCAS::DoubleFunc::hash ); DoubleFunc_exposer.def( "hash" , hash_function_value , "Return a has for the function" ); } { //::SireCAS::DoubleFunc::integrate typedef ::SireCAS::Expression ( ::SireCAS::DoubleFunc::*integrate_function_type)( ::SireCAS::Symbol const & ) const; integrate_function_type integrate_function_value( &::SireCAS::DoubleFunc::integrate ); DoubleFunc_exposer.def( "integrate" , integrate_function_value , ( bp::arg("symbol") ) , "Return the integral of this function with respect to symbol" ); } { //::SireCAS::DoubleFunc::isComplex typedef bool ( ::SireCAS::DoubleFunc::*isComplex_function_type)( ) const; isComplex_function_type isComplex_function_value( &::SireCAS::DoubleFunc::isComplex ); DoubleFunc_exposer.def( "isComplex" , isComplex_function_value , "Return whether this is complex" ); } { //::SireCAS::DoubleFunc::isCompound typedef bool ( ::SireCAS::DoubleFunc::*isCompound_function_type)( ) const; isCompound_function_type isCompound_function_value( &::SireCAS::DoubleFunc::isCompound ); DoubleFunc_exposer.def( "isCompound" , isCompound_function_value , "A function is not compound" ); } { //::SireCAS::DoubleFunc::isConstant typedef bool ( ::SireCAS::DoubleFunc::*isConstant_function_type)( ) const; isConstant_function_type isConstant_function_value( &::SireCAS::DoubleFunc::isConstant ); DoubleFunc_exposer.def( "isConstant" , isConstant_function_value , "Return whether or not this is constant" ); } { //::SireCAS::DoubleFunc::isFunction typedef bool ( ::SireCAS::DoubleFunc::*isFunction_function_type)( ::SireCAS::Symbol const & ) const; isFunction_function_type isFunction_function_value( &::SireCAS::DoubleFunc::isFunction ); DoubleFunc_exposer.def( "isFunction" , isFunction_function_value , ( bp::arg("symbol") ) , "Return if this is a function of symbol" ); } { //::SireCAS::DoubleFunc::operator= typedef ::SireCAS::DoubleFunc & ( ::SireCAS::DoubleFunc::*assign_function_type)( ::SireCAS::DoubleFunc const & ) ; assign_function_type assign_function_value( &::SireCAS::DoubleFunc::operator= ); DoubleFunc_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } { //::SireCAS::DoubleFunc::substitute typedef ::SireCAS::Expression ( ::SireCAS::DoubleFunc::*substitute_function_type)( ::SireCAS::Identities const & ) const; substitute_function_type substitute_function_value( &::SireCAS::DoubleFunc::substitute ); DoubleFunc_exposer.def( "substitute" , substitute_function_value , ( bp::arg("identities") ) , "Substitute into this expression" ); } { //::SireCAS::DoubleFunc::symbols typedef ::SireCAS::Symbols ( ::SireCAS::DoubleFunc::*symbols_function_type)( ) const; symbols_function_type symbols_function_value( &::SireCAS::DoubleFunc::symbols ); DoubleFunc_exposer.def( "symbols" , symbols_function_value , "Return the symbols used in this function" ); } { //::SireCAS::DoubleFunc::toString typedef ::QString ( ::SireCAS::DoubleFunc::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireCAS::DoubleFunc::toString ); DoubleFunc_exposer.def( "toString" , toString_function_value , "Return a string representation of this function" ); } { //::SireCAS::DoubleFunc::x typedef ::SireCAS::Expression const & ( ::SireCAS::DoubleFunc::*x_function_type)( ) const; x_function_type x_function_value( &::SireCAS::DoubleFunc::x ); DoubleFunc_exposer.def( "x" , x_function_value , bp::return_value_policy< bp::copy_const_reference >() , "" ); } { //::SireCAS::DoubleFunc::y typedef ::SireCAS::Expression const & ( ::SireCAS::DoubleFunc::*y_function_type)( ) const; y_function_type y_function_value( &::SireCAS::DoubleFunc::y ); DoubleFunc_exposer.def( "y" , y_function_value , bp::return_value_policy< bp::copy_const_reference >() , "" ); } DoubleFunc_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::DoubleFunc >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); DoubleFunc_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::DoubleFunc >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); DoubleFunc_exposer.def( "__str__", &__str__< ::SireCAS::DoubleFunc > ); DoubleFunc_exposer.def( "__repr__", &__str__< ::SireCAS::DoubleFunc > ); DoubleFunc_exposer.def( "__hash__", &::SireCAS::DoubleFunc::hash ); } }
void register_FFIdx_class(){ { //::SireFF::FFIdx typedef bp::class_< SireFF::FFIdx, bp::bases< SireFF::FFID, SireID::ID, SireID::IndexBase > > FFIdx_exposer_t; FFIdx_exposer_t FFIdx_exposer = FFIdx_exposer_t( "FFIdx", "This is an ID object that is used to index forcefields (e.g. index\nin a list or array).\n\nAuthor: Christopher Woods\n", bp::init< >("") ); bp::scope FFIdx_scope( FFIdx_exposer ); FFIdx_exposer.def( bp::init< qint32 >(( bp::arg("idx") ), "") ); FFIdx_exposer.def( bp::init< SireFF::FFIdx const & >(( bp::arg("other") ), "") ); { //::SireFF::FFIdx::hash typedef ::uint ( ::SireFF::FFIdx::*hash_function_type)( ) const; hash_function_type hash_function_value( &::SireFF::FFIdx::hash ); FFIdx_exposer.def( "hash" , hash_function_value , "" ); } { //::SireFF::FFIdx::isNull typedef bool ( ::SireFF::FFIdx::*isNull_function_type)( ) const; isNull_function_type isNull_function_value( &::SireFF::FFIdx::isNull ); FFIdx_exposer.def( "isNull" , isNull_function_value , "" ); } { //::SireFF::FFIdx::map typedef ::QList< SireFF::FFIdx > ( ::SireFF::FFIdx::*map_function_type)( ::SireFF::ForceFields const & ) const; map_function_type map_function_value( &::SireFF::FFIdx::map ); FFIdx_exposer.def( "map" , map_function_value , ( bp::arg("ffields") ) , "Short cut function to map this index to the index of the\nmatching forcefield in the passed ForceFields object\nThrow: SireError::invalid_index\n" ); } { //::SireFF::FFIdx::null typedef ::SireFF::FFIdx ( *null_function_type )( ); null_function_type null_function_value( &::SireFF::FFIdx::null ); FFIdx_exposer.def( "null" , null_function_value , "" ); } { //::SireFF::FFIdx::operator= typedef ::SireFF::FFIdx & ( ::SireFF::FFIdx::*assign_function_type)( ::SireFF::FFIdx const & ) ; assign_function_type assign_function_value( &::SireFF::FFIdx::operator= ); FFIdx_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } { //::SireFF::FFIdx::toString typedef ::QString ( ::SireFF::FFIdx::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireFF::FFIdx::toString ); FFIdx_exposer.def( "toString" , toString_function_value , "" ); } { //::SireFF::FFIdx::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireFF::FFIdx::typeName ); FFIdx_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireFF::FFIdx::what typedef char const * ( ::SireFF::FFIdx::*what_function_type)( ) const; what_function_type what_function_value( &::SireFF::FFIdx::what ); FFIdx_exposer.def( "what" , what_function_value , "" ); } FFIdx_exposer.staticmethod( "null" ); FFIdx_exposer.staticmethod( "typeName" ); FFIdx_exposer.def( "__copy__", &__copy__); FFIdx_exposer.def( "__deepcopy__", &__copy__); FFIdx_exposer.def( "clone", &__copy__); FFIdx_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireFF::FFIdx >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); FFIdx_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireFF::FFIdx >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); FFIdx_exposer.def( "__str__", &__str__< ::SireFF::FFIdx > ); FFIdx_exposer.def( "__repr__", &__str__< ::SireFF::FFIdx > ); FFIdx_exposer.def( "__hash__", &::SireFF::FFIdx::hash ); } }
void register_ExpressionBase_class(){ { //::SireCAS::ExpressionBase typedef bp::class_< SireCAS::ExpressionBase > ExpressionBase_exposer_t; ExpressionBase_exposer_t ExpressionBase_exposer = ExpressionBase_exposer_t( "ExpressionBase", bp::init< >() ); bp::scope ExpressionBase_scope( ExpressionBase_exposer ); ExpressionBase_exposer.def( bp::init< SireCAS::ExBase const & >(( bp::arg("ex") )) ); ExpressionBase_exposer.def( bp::init< SireCAS::ExpressionBase const & >(( bp::arg("other") )) ); { //::SireCAS::ExpressionBase::children typedef ::SireCAS::Expressions ( ::SireCAS::ExpressionBase::*children_function_type )( ) const; children_function_type children_function_value( &::SireCAS::ExpressionBase::children ); ExpressionBase_exposer.def( "children" , children_function_value ); } { //::SireCAS::ExpressionBase::conjugate typedef ::SireCAS::Expression ( ::SireCAS::ExpressionBase::*conjugate_function_type )( ) const; conjugate_function_type conjugate_function_value( &::SireCAS::ExpressionBase::conjugate ); ExpressionBase_exposer.def( "conjugate" , conjugate_function_value ); } { //::SireCAS::ExpressionBase::differentiate typedef ::SireCAS::Expression ( ::SireCAS::ExpressionBase::*differentiate_function_type )( ::SireCAS::Symbol const & ) const; differentiate_function_type differentiate_function_value( &::SireCAS::ExpressionBase::differentiate ); ExpressionBase_exposer.def( "differentiate" , differentiate_function_value , ( bp::arg("symbol") ) ); } { //::SireCAS::ExpressionBase::evaluate typedef double ( ::SireCAS::ExpressionBase::*evaluate_function_type )( ::SireCAS::Values const & ) const; evaluate_function_type evaluate_function_value( &::SireCAS::ExpressionBase::evaluate ); ExpressionBase_exposer.def( "evaluate" , evaluate_function_value , ( bp::arg("values") ) ); } { //::SireCAS::ExpressionBase::evaluate typedef ::SireMaths::Complex ( ::SireCAS::ExpressionBase::*evaluate_function_type )( ::SireCAS::ComplexValues const & ) const; evaluate_function_type evaluate_function_value( &::SireCAS::ExpressionBase::evaluate ); ExpressionBase_exposer.def( "evaluate" , evaluate_function_value , ( bp::arg("values") ) ); } { //::SireCAS::ExpressionBase::expand typedef ::QList< SireCAS::Factor > ( ::SireCAS::ExpressionBase::*expand_function_type )( ::SireCAS::Symbol const & ) const; expand_function_type expand_function_value( &::SireCAS::ExpressionBase::expand ); ExpressionBase_exposer.def( "expand" , expand_function_value , ( bp::arg("symbol") ) ); } { //::SireCAS::ExpressionBase::functions typedef ::SireCAS::Functions ( ::SireCAS::ExpressionBase::*functions_function_type )( ) const; functions_function_type functions_function_value( &::SireCAS::ExpressionBase::functions ); ExpressionBase_exposer.def( "functions" , functions_function_value ); } { //::SireCAS::ExpressionBase::hash typedef ::uint ( ::SireCAS::ExpressionBase::*hash_function_type )( ) const; hash_function_type hash_function_value( &::SireCAS::ExpressionBase::hash ); ExpressionBase_exposer.def( "hash" , hash_function_value ); } { //::SireCAS::ExpressionBase::integrate typedef ::SireCAS::Expression ( ::SireCAS::ExpressionBase::*integrate_function_type )( ::SireCAS::Symbol const & ) const; integrate_function_type integrate_function_value( &::SireCAS::ExpressionBase::integrate ); ExpressionBase_exposer.def( "integrate" , integrate_function_value , ( bp::arg("symbol") ) ); } { //::SireCAS::ExpressionBase::isComplex typedef bool ( ::SireCAS::ExpressionBase::*isComplex_function_type )( ) const; isComplex_function_type isComplex_function_value( &::SireCAS::ExpressionBase::isComplex ); ExpressionBase_exposer.def( "isComplex" , isComplex_function_value ); } { //::SireCAS::ExpressionBase::isCompound typedef bool ( ::SireCAS::ExpressionBase::*isCompound_function_type )( ) const; isCompound_function_type isCompound_function_value( &::SireCAS::ExpressionBase::isCompound ); ExpressionBase_exposer.def( "isCompound" , isCompound_function_value ); } { //::SireCAS::ExpressionBase::isConstant typedef bool ( ::SireCAS::ExpressionBase::*isConstant_function_type )( ) const; isConstant_function_type isConstant_function_value( &::SireCAS::ExpressionBase::isConstant ); ExpressionBase_exposer.def( "isConstant" , isConstant_function_value ); } { //::SireCAS::ExpressionBase::isFunction typedef bool ( ::SireCAS::ExpressionBase::*isFunction_function_type )( ::SireCAS::Symbol const & ) const; isFunction_function_type isFunction_function_value( &::SireCAS::ExpressionBase::isFunction ); ExpressionBase_exposer.def( "isFunction" , isFunction_function_value , ( bp::arg("arg0") ) ); } ExpressionBase_exposer.def( bp::self != bp::self ); { //::SireCAS::ExpressionBase::operator= typedef ::SireCAS::ExpressionBase & ( ::SireCAS::ExpressionBase::*assign_function_type )( ::SireCAS::ExpressionBase const & ) ; assign_function_type assign_function_value( &::SireCAS::ExpressionBase::operator= ); ExpressionBase_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } { //::SireCAS::ExpressionBase::operator= typedef ::SireCAS::ExpressionBase & ( ::SireCAS::ExpressionBase::*assign_function_type )( ::SireCAS::ExBase const & ) ; assign_function_type assign_function_value( &::SireCAS::ExpressionBase::operator= ); ExpressionBase_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } ExpressionBase_exposer.def( bp::self == bp::self ); { //::SireCAS::ExpressionBase::series typedef ::SireCAS::Expression ( ::SireCAS::ExpressionBase::*series_function_type )( ::SireCAS::Symbol const &,int ) const; series_function_type series_function_value( &::SireCAS::ExpressionBase::series ); ExpressionBase_exposer.def( "series" , series_function_value , ( bp::arg("symbol"), bp::arg("n") ) ); } { //::SireCAS::ExpressionBase::simplify typedef ::SireCAS::Expression ( ::SireCAS::ExpressionBase::*simplify_function_type )( int ) const; simplify_function_type simplify_function_value( &::SireCAS::ExpressionBase::simplify ); ExpressionBase_exposer.def( "simplify" , simplify_function_value , ( bp::arg("options")=(int)(0) ) ); } { //::SireCAS::ExpressionBase::substitute typedef ::SireCAS::Expression ( ::SireCAS::ExpressionBase::*substitute_function_type )( ::SireCAS::Identities const & ) const; substitute_function_type substitute_function_value( &::SireCAS::ExpressionBase::substitute ); ExpressionBase_exposer.def( "substitute" , substitute_function_value , ( bp::arg("identities") ) ); } { //::SireCAS::ExpressionBase::symbols typedef ::SireCAS::Symbols ( ::SireCAS::ExpressionBase::*symbols_function_type )( ) const; symbols_function_type symbols_function_value( &::SireCAS::ExpressionBase::symbols ); ExpressionBase_exposer.def( "symbols" , symbols_function_value ); } { //::SireCAS::ExpressionBase::toString typedef ::QString ( ::SireCAS::ExpressionBase::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireCAS::ExpressionBase::toString ); ExpressionBase_exposer.def( "toString" , toString_function_value ); } { //::SireCAS::ExpressionBase::what typedef char const * ( ::SireCAS::ExpressionBase::*what_function_type )( ) const; what_function_type what_function_value( &::SireCAS::ExpressionBase::what ); ExpressionBase_exposer.def( "what" , what_function_value ); } ExpressionBase_exposer.def( "__copy__", &__copy__); ExpressionBase_exposer.def( "__deepcopy__", &__copy__); ExpressionBase_exposer.def( "clone", &__copy__); ExpressionBase_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::ExpressionBase >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); ExpressionBase_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::ExpressionBase >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); ExpressionBase_exposer.def( "__str__", &__str__< ::SireCAS::ExpressionBase > ); ExpressionBase_exposer.def( "__repr__", &__str__< ::SireCAS::ExpressionBase > ); } }
void register_ChainAtomID_class(){ { //::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID > typedef bp::class_< SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >, bp::bases< SireMol::GroupAtomIDBase, SireMol::AtomID, SireID::ID > > ChainAtomID_exposer_t; ChainAtomID_exposer_t ChainAtomID_exposer = ChainAtomID_exposer_t( "ChainAtomID", "", bp::init< >("") ); bp::scope ChainAtomID_scope( ChainAtomID_exposer ); ChainAtomID_exposer.def( bp::init< SireMol::ChainID const &, SireMol::AtomID const & >(( bp::arg("group"), bp::arg("atom") ), "") ); ChainAtomID_exposer.def( bp::init< SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID > const & >(( bp::arg("other") ), "") ); { //::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::hash typedef SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID > exported_class_t; typedef ::uint ( ::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::*hash_function_type)( ) const; hash_function_type hash_function_value( &::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::hash ); ChainAtomID_exposer.def( "hash" , hash_function_value , "" ); } { //::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::isNull typedef SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID > exported_class_t; typedef bool ( ::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::*isNull_function_type)( ) const; isNull_function_type isNull_function_value( &::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::isNull ); ChainAtomID_exposer.def( "isNull" , isNull_function_value , "" ); } { //::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::map typedef SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID > exported_class_t; typedef ::QList< SireMol::AtomIdx > ( ::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::*map_function_type)( ::SireMol::MolInfo const & ) const; map_function_type map_function_value( &::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::map ); ChainAtomID_exposer.def( "map" , map_function_value , ( bp::arg("molinfo") ) , "" ); } ChainAtomID_exposer.def( bp::self != bp::self ); ChainAtomID_exposer.def( bp::self == bp::self ); ChainAtomID_exposer.def( bp::self == bp::other< SireID::ID >() ); { //::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::toString typedef SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID > exported_class_t; typedef ::QString ( ::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::toString ); ChainAtomID_exposer.def( "toString" , toString_function_value , "" ); } { //::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::typeName typedef SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID > exported_class_t; typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::typeName ); ChainAtomID_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::what typedef SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID > exported_class_t; typedef char const * ( ::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::*what_function_type)( ) const; what_function_type what_function_value( &::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::what ); ChainAtomID_exposer.def( "what" , what_function_value , "" ); } ChainAtomID_exposer.staticmethod( "typeName" ); ChainAtomID_exposer.def( "__copy__", &__copy__); ChainAtomID_exposer.def( "__deepcopy__", &__copy__); ChainAtomID_exposer.def( "clone", &__copy__); ChainAtomID_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::GroupAtomID<SireMol::ChainID, SireMol::AtomID> >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); ChainAtomID_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::GroupAtomID<SireMol::ChainID, SireMol::AtomID> >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); ChainAtomID_exposer.def( "__str__", &__str__< ::SireMol::GroupAtomID<SireMol::ChainID, SireMol::AtomID> > ); ChainAtomID_exposer.def( "__repr__", &__str__< ::SireMol::GroupAtomID<SireMol::ChainID, SireMol::AtomID> > ); ChainAtomID_exposer.def( "__hash__", &::SireMol::GroupAtomID<SireMol::ChainID, SireMol::AtomID>::hash ); } }
void register_ChainsWithRes_class(){ { //::SireMol::ChainsWithRes typedef bp::class_< SireMol::ChainsWithRes, bp::bases< SireMol::ChainID, SireID::ID > > ChainsWithRes_exposer_t; ChainsWithRes_exposer_t ChainsWithRes_exposer = ChainsWithRes_exposer_t( "ChainsWithRes", "This ID class identifies chains that contain residues that\nmatch the passed ResID\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") ); bp::scope ChainsWithRes_scope( ChainsWithRes_exposer ); ChainsWithRes_exposer.def( bp::init< SireMol::ResID const & >(( bp::arg("resid") ), "Construct from the passed residue ID") ); ChainsWithRes_exposer.def( bp::init< SireMol::ChainsWithRes const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireMol::ChainsWithRes::hash typedef ::uint ( ::SireMol::ChainsWithRes::*hash_function_type)( ) const; hash_function_type hash_function_value( &::SireMol::ChainsWithRes::hash ); ChainsWithRes_exposer.def( "hash" , hash_function_value , "Return a hash of this identifier" ); } { //::SireMol::ChainsWithRes::isNull typedef bool ( ::SireMol::ChainsWithRes::*isNull_function_type)( ) const; isNull_function_type isNull_function_value( &::SireMol::ChainsWithRes::isNull ); ChainsWithRes_exposer.def( "isNull" , isNull_function_value , "Is this selection null?" ); } { //::SireMol::ChainsWithRes::map typedef ::QList< SireMol::ChainIdx > ( ::SireMol::ChainsWithRes::*map_function_type)( ::SireMol::MolInfo const & ) const; map_function_type map_function_value( &::SireMol::ChainsWithRes::map ); ChainsWithRes_exposer.def( "map" , map_function_value , ( bp::arg("molinfo") ) , "Map this ID to the list of indicies of chains that match this ID\nThrow: SireMol::missing_chain\nThrow: SireError::invalid_index\n" ); } ChainsWithRes_exposer.def( bp::self != bp::self ); { //::SireMol::ChainsWithRes::operator= typedef ::SireMol::ChainsWithRes & ( ::SireMol::ChainsWithRes::*assign_function_type)( ::SireMol::ChainsWithRes const & ) ; assign_function_type assign_function_value( &::SireMol::ChainsWithRes::operator= ); ChainsWithRes_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } ChainsWithRes_exposer.def( bp::self == bp::other< SireID::ID >() ); ChainsWithRes_exposer.def( bp::self == bp::self ); { //::SireMol::ChainsWithRes::resID typedef ::SireMol::ResID const & ( ::SireMol::ChainsWithRes::*resID_function_type)( ) const; resID_function_type resID_function_value( &::SireMol::ChainsWithRes::resID ); ChainsWithRes_exposer.def( "resID" , resID_function_value , bp::return_value_policy<bp::clone_const_reference>() , "Return the residue ID" ); } { //::SireMol::ChainsWithRes::toString typedef ::QString ( ::SireMol::ChainsWithRes::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireMol::ChainsWithRes::toString ); ChainsWithRes_exposer.def( "toString" , toString_function_value , "Return a string representatio of this ID" ); } { //::SireMol::ChainsWithRes::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMol::ChainsWithRes::typeName ); ChainsWithRes_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireMol::ChainsWithRes::what typedef char const * ( ::SireMol::ChainsWithRes::*what_function_type)( ) const; what_function_type what_function_value( &::SireMol::ChainsWithRes::what ); ChainsWithRes_exposer.def( "what" , what_function_value , "" ); } ChainsWithRes_exposer.staticmethod( "typeName" ); ChainsWithRes_exposer.def( "__copy__", &__copy__); ChainsWithRes_exposer.def( "__deepcopy__", &__copy__); ChainsWithRes_exposer.def( "clone", &__copy__); ChainsWithRes_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::ChainsWithRes >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); ChainsWithRes_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::ChainsWithRes >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); ChainsWithRes_exposer.def( "__str__", &__str__< ::SireMol::ChainsWithRes > ); ChainsWithRes_exposer.def( "__repr__", &__str__< ::SireMol::ChainsWithRes > ); ChainsWithRes_exposer.def( "__hash__", &::SireMol::ChainsWithRes::hash ); } }
void register_Expression_class(){ { //::SireCAS::Expression typedef bp::class_< SireCAS::Expression > Expression_exposer_t; Expression_exposer_t Expression_exposer = Expression_exposer_t( "Expression", bp::init< >() ); bp::scope Expression_scope( Expression_exposer ); Expression_exposer.def( bp::init< int >(( bp::arg("constant") )) ); Expression_exposer.def( bp::init< SireMaths::Rational const & >(( bp::arg("constant") )) ); Expression_exposer.def( bp::init< double >(( bp::arg("constant") )) ); Expression_exposer.def( bp::init< SireMaths::Complex const & >(( bp::arg("constant") )) ); Expression_exposer.def( bp::init< SireCAS::ExpressionBase const & >(( bp::arg("base") )) ); Expression_exposer.def( bp::init< SireCAS::ExBase const & >(( bp::arg("base") )) ); Expression_exposer.def( bp::init< SireCAS::Expression const & >(( bp::arg("other") )) ); { //::SireCAS::Expression::add typedef ::SireCAS::Expression ( ::SireCAS::Expression::*add_function_type )( ::SireCAS::Expression const & ) const; add_function_type add_function_value( &::SireCAS::Expression::add ); Expression_exposer.def( "add" , add_function_value , ( bp::arg("ex") ) ); } { //::SireCAS::Expression::add typedef ::SireCAS::Expression ( ::SireCAS::Expression::*add_function_type )( double ) const; add_function_type add_function_value( &::SireCAS::Expression::add ); Expression_exposer.def( "add" , add_function_value , ( bp::arg("val") ) ); } { //::SireCAS::Expression::add typedef ::SireCAS::Expression ( ::SireCAS::Expression::*add_function_type )( ::SireMaths::Complex const & ) const; add_function_type add_function_value( &::SireCAS::Expression::add ); Expression_exposer.def( "add" , add_function_value , ( bp::arg("val") ) ); } { //::SireCAS::Expression::base typedef ::SireCAS::ExpressionBase const & ( ::SireCAS::Expression::*base_function_type )( ) const; base_function_type base_function_value( &::SireCAS::Expression::base ); Expression_exposer.def( "base" , base_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireCAS::Expression::children typedef ::SireCAS::Expressions ( ::SireCAS::Expression::*children_function_type )( ) const; children_function_type children_function_value( &::SireCAS::Expression::children ); Expression_exposer.def( "children" , children_function_value ); } { //::SireCAS::Expression::conjugate typedef ::SireCAS::Expression ( ::SireCAS::Expression::*conjugate_function_type )( ) const; conjugate_function_type conjugate_function_value( &::SireCAS::Expression::conjugate ); Expression_exposer.def( "conjugate" , conjugate_function_value ); } { //::SireCAS::Expression::cubed typedef ::SireCAS::Expression ( ::SireCAS::Expression::*cubed_function_type )( ) const; cubed_function_type cubed_function_value( &::SireCAS::Expression::cubed ); Expression_exposer.def( "cubed" , cubed_function_value ); } { //::SireCAS::Expression::diff typedef ::SireCAS::Expression ( ::SireCAS::Expression::*diff_function_type )( ::SireCAS::Symbol const &,int ) const; diff_function_type diff_function_value( &::SireCAS::Expression::diff ); Expression_exposer.def( "diff" , diff_function_value , ( bp::arg("symbol"), bp::arg("level")=(int)(1) ) ); } { //::SireCAS::Expression::differentiate typedef ::SireCAS::Expression ( ::SireCAS::Expression::*differentiate_function_type )( ::SireCAS::Symbol const &,int ) const; differentiate_function_type differentiate_function_value( &::SireCAS::Expression::differentiate ); Expression_exposer.def( "differentiate" , differentiate_function_value , ( bp::arg("symbol"), bp::arg("level")=(int)(1) ) ); } { //::SireCAS::Expression::divide typedef ::SireCAS::Expression ( ::SireCAS::Expression::*divide_function_type )( ::SireCAS::Expression const & ) const; divide_function_type divide_function_value( &::SireCAS::Expression::divide ); Expression_exposer.def( "divide" , divide_function_value , ( bp::arg("ex") ) ); } { //::SireCAS::Expression::divide typedef ::SireCAS::Expression ( ::SireCAS::Expression::*divide_function_type )( double ) const; divide_function_type divide_function_value( &::SireCAS::Expression::divide ); Expression_exposer.def( "divide" , divide_function_value , ( bp::arg("val") ) ); } { //::SireCAS::Expression::divide typedef ::SireCAS::Expression ( ::SireCAS::Expression::*divide_function_type )( ::SireMaths::Complex const & ) const; divide_function_type divide_function_value( &::SireCAS::Expression::divide ); Expression_exposer.def( "divide" , divide_function_value , ( bp::arg("val") ) ); } { //::SireCAS::Expression::evaluate typedef double ( ::SireCAS::Expression::*evaluate_function_type )( ::SireCAS::Values const & ) const; evaluate_function_type evaluate_function_value( &::SireCAS::Expression::evaluate ); Expression_exposer.def( "evaluate" , evaluate_function_value , ( bp::arg("values") ) ); } { //::SireCAS::Expression::evaluate typedef ::SireMaths::Complex ( ::SireCAS::Expression::*evaluate_function_type )( ::SireCAS::ComplexValues const & ) const; evaluate_function_type evaluate_function_value( &::SireCAS::Expression::evaluate ); Expression_exposer.def( "evaluate" , evaluate_function_value , ( bp::arg("values") ) ); } { //::SireCAS::Expression::expand typedef ::QList< SireCAS::Factor > ( ::SireCAS::Expression::*expand_function_type )( ::SireCAS::Symbol const & ) const; expand_function_type expand_function_value( &::SireCAS::Expression::expand ); Expression_exposer.def( "expand" , expand_function_value , ( bp::arg("symbol") ) ); } { //::SireCAS::Expression::factor typedef double ( ::SireCAS::Expression::*factor_function_type )( ) const; factor_function_type factor_function_value( &::SireCAS::Expression::factor ); Expression_exposer.def( "factor" , factor_function_value ); } { //::SireCAS::Expression::functions typedef ::SireCAS::Functions ( ::SireCAS::Expression::*functions_function_type )( ) const; functions_function_type functions_function_value( &::SireCAS::Expression::functions ); Expression_exposer.def( "functions" , functions_function_value ); } { //::SireCAS::Expression::hash typedef ::uint ( ::SireCAS::Expression::*hash_function_type )( ) const; hash_function_type hash_function_value( &::SireCAS::Expression::hash ); Expression_exposer.def( "hash" , hash_function_value ); } { //::SireCAS::Expression::integ typedef ::SireCAS::Expression ( ::SireCAS::Expression::*integ_function_type )( ::SireCAS::Symbol const & ) const; integ_function_type integ_function_value( &::SireCAS::Expression::integ ); Expression_exposer.def( "integ" , integ_function_value , ( bp::arg("symbol") ) ); } { //::SireCAS::Expression::integrate typedef ::SireCAS::Expression ( ::SireCAS::Expression::*integrate_function_type )( ::SireCAS::Symbol const & ) const; integrate_function_type integrate_function_value( &::SireCAS::Expression::integrate ); Expression_exposer.def( "integrate" , integrate_function_value , ( bp::arg("symbol") ) ); } { //::SireCAS::Expression::invert typedef ::SireCAS::Expression ( ::SireCAS::Expression::*invert_function_type )( ) const; invert_function_type invert_function_value( &::SireCAS::Expression::invert ); Expression_exposer.def( "invert" , invert_function_value ); } { //::SireCAS::Expression::isComplex typedef bool ( ::SireCAS::Expression::*isComplex_function_type )( ) const; isComplex_function_type isComplex_function_value( &::SireCAS::Expression::isComplex ); Expression_exposer.def( "isComplex" , isComplex_function_value ); } { //::SireCAS::Expression::isCompound typedef bool ( ::SireCAS::Expression::*isCompound_function_type )( ) const; isCompound_function_type isCompound_function_value( &::SireCAS::Expression::isCompound ); Expression_exposer.def( "isCompound" , isCompound_function_value ); } { //::SireCAS::Expression::isConstant typedef bool ( ::SireCAS::Expression::*isConstant_function_type )( ) const; isConstant_function_type isConstant_function_value( &::SireCAS::Expression::isConstant ); Expression_exposer.def( "isConstant" , isConstant_function_value ); } { //::SireCAS::Expression::isFunction typedef bool ( ::SireCAS::Expression::*isFunction_function_type )( ::SireCAS::Symbol const & ) const; isFunction_function_type isFunction_function_value( &::SireCAS::Expression::isFunction ); Expression_exposer.def( "isFunction" , isFunction_function_value , ( bp::arg("symbol") ) ); } { //::SireCAS::Expression::isZero typedef bool ( ::SireCAS::Expression::*isZero_function_type )( ) const; isZero_function_type isZero_function_value( &::SireCAS::Expression::isZero ); Expression_exposer.def( "isZero" , isZero_function_value ); } { //::SireCAS::Expression::multiply typedef ::SireCAS::Expression ( ::SireCAS::Expression::*multiply_function_type )( ::SireCAS::Expression const & ) const; multiply_function_type multiply_function_value( &::SireCAS::Expression::multiply ); Expression_exposer.def( "multiply" , multiply_function_value , ( bp::arg("ex") ) ); } { //::SireCAS::Expression::multiply typedef ::SireCAS::Expression ( ::SireCAS::Expression::*multiply_function_type )( double ) const; multiply_function_type multiply_function_value( &::SireCAS::Expression::multiply ); Expression_exposer.def( "multiply" , multiply_function_value , ( bp::arg("val") ) ); } { //::SireCAS::Expression::multiply typedef ::SireCAS::Expression ( ::SireCAS::Expression::*multiply_function_type )( ::SireMaths::Complex const & ) const; multiply_function_type multiply_function_value( &::SireCAS::Expression::multiply ); Expression_exposer.def( "multiply" , multiply_function_value , ( bp::arg("val") ) ); } { //::SireCAS::Expression::negate typedef ::SireCAS::Expression ( ::SireCAS::Expression::*negate_function_type )( ) const; negate_function_type negate_function_value( &::SireCAS::Expression::negate ); Expression_exposer.def( "negate" , negate_function_value ); } Expression_exposer.def( bp::self != bp::self ); { //::SireCAS::Expression::operator() typedef double ( ::SireCAS::Expression::*__call___function_type )( ::SireCAS::Values const & ) const; __call___function_type __call___function_value( &::SireCAS::Expression::operator() ); Expression_exposer.def( "__call__" , __call___function_value , ( bp::arg("values") ) ); } { //::SireCAS::Expression::operator() typedef ::SireMaths::Complex ( ::SireCAS::Expression::*__call___function_type )( ::SireCAS::ComplexValues const & ) const; __call___function_type __call___function_value( &::SireCAS::Expression::operator() ); Expression_exposer.def( "__call__" , __call___function_value , ( bp::arg("values") ) ); } Expression_exposer.def( -bp::self ); { //::SireCAS::Expression::operator= typedef ::SireCAS::Expression & ( ::SireCAS::Expression::*assign_function_type )( ::SireCAS::Expression const & ) ; assign_function_type assign_function_value( &::SireCAS::Expression::operator= ); Expression_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } Expression_exposer.def( bp::self == bp::self ); { //::SireCAS::Expression::pow typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( int ) const; pow_function_type pow_function_value( &::SireCAS::Expression::pow ); Expression_exposer.def( "pow" , pow_function_value , ( bp::arg("n") ) ); } { //::SireCAS::Expression::pow typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( ::SireMaths::Rational const & ) const; pow_function_type pow_function_value( &::SireCAS::Expression::pow ); Expression_exposer.def( "pow" , pow_function_value , ( bp::arg("n") ) ); } { //::SireCAS::Expression::pow typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( double ) const; pow_function_type pow_function_value( &::SireCAS::Expression::pow ); Expression_exposer.def( "pow" , pow_function_value , ( bp::arg("n") ) ); } { //::SireCAS::Expression::pow typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( ::SireMaths::Complex const & ) const; pow_function_type pow_function_value( &::SireCAS::Expression::pow ); Expression_exposer.def( "pow" , pow_function_value , ( bp::arg("n") ) ); } { //::SireCAS::Expression::pow typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( ::SireCAS::Expression const & ) const; pow_function_type pow_function_value( &::SireCAS::Expression::pow ); Expression_exposer.def( "pow" , pow_function_value , ( bp::arg("n") ) ); } { //::SireCAS::Expression::root typedef ::SireCAS::Expression ( ::SireCAS::Expression::*root_function_type )( int ) const; root_function_type root_function_value( &::SireCAS::Expression::root ); Expression_exposer.def( "root" , root_function_value , ( bp::arg("n") ) ); } { //::SireCAS::Expression::series typedef ::SireCAS::Expression ( ::SireCAS::Expression::*series_function_type )( ::SireCAS::Symbol const &,int ) const; series_function_type series_function_value( &::SireCAS::Expression::series ); Expression_exposer.def( "series" , series_function_value , ( bp::arg("symbol"), bp::arg("order") ) ); } { //::SireCAS::Expression::simplify typedef ::SireCAS::Expression ( ::SireCAS::Expression::*simplify_function_type )( int ) const; simplify_function_type simplify_function_value( &::SireCAS::Expression::simplify ); Expression_exposer.def( "simplify" , simplify_function_value , ( bp::arg("options")=(int)(0) ) ); } { //::SireCAS::Expression::squared typedef ::SireCAS::Expression ( ::SireCAS::Expression::*squared_function_type )( ) const; squared_function_type squared_function_value( &::SireCAS::Expression::squared ); Expression_exposer.def( "squared" , squared_function_value ); } { //::SireCAS::Expression::substitute typedef ::SireCAS::Expression ( ::SireCAS::Expression::*substitute_function_type )( ::SireCAS::Identities const & ) const; substitute_function_type substitute_function_value( &::SireCAS::Expression::substitute ); Expression_exposer.def( "substitute" , substitute_function_value , ( bp::arg("identities") ) ); } { //::SireCAS::Expression::subtract typedef ::SireCAS::Expression ( ::SireCAS::Expression::*subtract_function_type )( ::SireCAS::Expression const & ) const; subtract_function_type subtract_function_value( &::SireCAS::Expression::subtract ); Expression_exposer.def( "subtract" , subtract_function_value , ( bp::arg("ex") ) ); } { //::SireCAS::Expression::subtract typedef ::SireCAS::Expression ( ::SireCAS::Expression::*subtract_function_type )( double ) const; subtract_function_type subtract_function_value( &::SireCAS::Expression::subtract ); Expression_exposer.def( "subtract" , subtract_function_value , ( bp::arg("val") ) ); } { //::SireCAS::Expression::subtract typedef ::SireCAS::Expression ( ::SireCAS::Expression::*subtract_function_type )( ::SireMaths::Complex const & ) const; subtract_function_type subtract_function_value( &::SireCAS::Expression::subtract ); Expression_exposer.def( "subtract" , subtract_function_value , ( bp::arg("val") ) ); } { //::SireCAS::Expression::symbols typedef ::SireCAS::Symbols ( ::SireCAS::Expression::*symbols_function_type )( ) const; symbols_function_type symbols_function_value( &::SireCAS::Expression::symbols ); Expression_exposer.def( "symbols" , symbols_function_value ); } { //::SireCAS::Expression::toString typedef ::QString ( ::SireCAS::Expression::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireCAS::Expression::toString ); Expression_exposer.def( "toString" , toString_function_value ); } { //::SireCAS::Expression::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireCAS::Expression::typeName ); Expression_exposer.def( "typeName" , typeName_function_value ); } { //::SireCAS::Expression::what typedef char const * ( ::SireCAS::Expression::*what_function_type )( ) const; what_function_type what_function_value( &::SireCAS::Expression::what ); Expression_exposer.def( "what" , what_function_value ); } Expression_exposer.staticmethod( "typeName" ); Expression_exposer.def( bp::self * bp::other< SireMaths::Complex >() ); Expression_exposer.def( bp::other< SireMaths::Complex >() * bp::self ); Expression_exposer.def( bp::self * bp::other< double >() ); Expression_exposer.def( bp::other< double >() * bp::self ); Expression_exposer.def( bp::self * bp::self ); Expression_exposer.def( bp::self * bp::other< SireCAS::ExBase >() ); Expression_exposer.def( bp::other< SireMaths::Complex >() + bp::self ); Expression_exposer.def( bp::self + bp::other< SireMaths::Complex >() ); Expression_exposer.def( bp::other< double >() + bp::self ); Expression_exposer.def( bp::self + bp::other< double >() ); Expression_exposer.def( bp::self + bp::self ); Expression_exposer.def( bp::self + bp::other< SireCAS::ExBase >() ); Expression_exposer.def( bp::other< double >() - bp::self ); Expression_exposer.def( bp::self - bp::other< double >() ); Expression_exposer.def( bp::self - bp::self ); Expression_exposer.def( bp::self - bp::other< SireCAS::ExBase >() ); Expression_exposer.def( bp::other< SireMaths::Complex >() / bp::self ); Expression_exposer.def( bp::self / bp::other< SireMaths::Complex >() ); Expression_exposer.def( bp::other< double >() / bp::self ); Expression_exposer.def( bp::self / bp::other< double >() ); Expression_exposer.def( bp::self / bp::self ); Expression_exposer.def( bp::self / bp::other< SireCAS::ExBase >() ); Expression_exposer.def( self + self ); Expression_exposer.def( self - self ); Expression_exposer.def( self * self ); Expression_exposer.def( self / self ); Expression_exposer.def( other<double>() + self ); Expression_exposer.def( other<double>() - self ); Expression_exposer.def( other<double>() * self ); Expression_exposer.def( other<double>() / self ); Expression_exposer.def( self + other<double>() ); Expression_exposer.def( self - other<double>() ); Expression_exposer.def( self * other<double>() ); Expression_exposer.def( self / other<double>() ); Expression_exposer.def( other<SireMaths::Complex>() + self ); Expression_exposer.def( other<SireMaths::Complex>() - self ); Expression_exposer.def( other<SireMaths::Complex>() * self ); Expression_exposer.def( other<SireMaths::Complex>() / self ); Expression_exposer.def( self + other<SireMaths::Complex>() ); Expression_exposer.def( self - other<SireMaths::Complex>() ); Expression_exposer.def( self * other<SireMaths::Complex>() ); Expression_exposer.def( self / other<SireMaths::Complex>() ); Expression_exposer.def( other<SireCAS::ExBase>() + self ); Expression_exposer.def( other<SireCAS::ExBase>() - self ); Expression_exposer.def( other<SireCAS::ExBase>() * self ); Expression_exposer.def( other<SireCAS::ExBase>() / self ); Expression_exposer.def( self + other<SireCAS::ExBase>() ); Expression_exposer.def( self - other<SireCAS::ExBase>() ); Expression_exposer.def( self * other<SireCAS::ExBase>() ); Expression_exposer.def( self / other<SireCAS::ExBase>() ); Expression_exposer.def( "__copy__", &__copy__); Expression_exposer.def( "__deepcopy__", &__copy__); Expression_exposer.def( "clone", &__copy__); Expression_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::Expression >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Expression_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::Expression >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Expression_exposer.def( "__str__", &__str__< ::SireCAS::Expression > ); Expression_exposer.def( "__repr__", &__str__< ::SireCAS::Expression > ); } }
void register_IDOrSet_SegID__class(){ { //::SireID::IDOrSet< SireMol::SegID > typedef bp::class_< SireID::IDOrSet< SireMol::SegID >, bp::bases< SireMol::SegID, SireID::ID > > IDOrSet_SegID__exposer_t; IDOrSet_SegID__exposer_t IDOrSet_SegID__exposer = IDOrSet_SegID__exposer_t( "IDOrSet_SegID_", bp::init< >() ); bp::scope IDOrSet_SegID__scope( IDOrSet_SegID__exposer ); IDOrSet_SegID__exposer.def( bp::init< SireMol::SegID const & >(( bp::arg("id") )) ); IDOrSet_SegID__exposer.def( bp::init< SireMol::SegID const &, SireMol::SegID const & >(( bp::arg("id0"), bp::arg("id1") )) ); IDOrSet_SegID__exposer.def( bp::init< QList< SireMol::SegIdentifier > const & >(( bp::arg("ids") )) ); IDOrSet_SegID__exposer.def( bp::init< SireID::IDOrSet< SireMol::SegID > const & >(( bp::arg("other") )) ); { //::SireID::IDOrSet< SireMol::SegID >::IDs typedef SireID::IDOrSet< SireMol::SegID > exported_class_t; typedef ::QSet< SireMol::SegIdentifier > const & ( ::SireID::IDOrSet< SireMol::SegID >::*IDs_function_type )( ) const; IDs_function_type IDs_function_value( &::SireID::IDOrSet< SireMol::SegID >::IDs ); IDOrSet_SegID__exposer.def( "IDs" , IDs_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireID::IDOrSet< SireMol::SegID >::hash typedef SireID::IDOrSet< SireMol::SegID > exported_class_t; typedef ::uint ( ::SireID::IDOrSet< SireMol::SegID >::*hash_function_type )( ) const; hash_function_type hash_function_value( &::SireID::IDOrSet< SireMol::SegID >::hash ); IDOrSet_SegID__exposer.def( "hash" , hash_function_value ); } { //::SireID::IDOrSet< SireMol::SegID >::isNull typedef SireID::IDOrSet< SireMol::SegID > exported_class_t; typedef bool ( ::SireID::IDOrSet< SireMol::SegID >::*isNull_function_type )( ) const; isNull_function_type isNull_function_value( &::SireID::IDOrSet< SireMol::SegID >::isNull ); IDOrSet_SegID__exposer.def( "isNull" , isNull_function_value ); } { //::SireID::IDOrSet< SireMol::SegID >::map typedef SireID::IDOrSet< SireMol::SegID > exported_class_t; typedef ::QList< SireMol::SegIdx > ( ::SireID::IDOrSet< SireMol::SegID >::*map_function_type )( ::SireMol::MolInfo const & ) const; map_function_type map_function_value( &::SireID::IDOrSet< SireMol::SegID >::map ); IDOrSet_SegID__exposer.def( "map" , map_function_value , ( bp::arg("obj") ) ); } IDOrSet_SegID__exposer.def( bp::self != bp::other< SireID::ID >() ); IDOrSet_SegID__exposer.def( bp::self != bp::self ); IDOrSet_SegID__exposer.def( bp::self != bp::other< SireMol::SegID >() ); { //::SireID::IDOrSet< SireMol::SegID >::operator= typedef SireID::IDOrSet< SireMol::SegID > exported_class_t; typedef ::SireID::IDOrSet< SireMol::SegID > & ( ::SireID::IDOrSet< SireMol::SegID >::*assign_function_type )( ::SireID::IDOrSet< SireMol::SegID > const & ) ; assign_function_type assign_function_value( &::SireID::IDOrSet< SireMol::SegID >::operator= ); IDOrSet_SegID__exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } { //::SireID::IDOrSet< SireMol::SegID >::operator= typedef SireID::IDOrSet< SireMol::SegID > exported_class_t; typedef ::SireID::IDOrSet< SireMol::SegID > & ( ::SireID::IDOrSet< SireMol::SegID >::*assign_function_type )( ::SireMol::SegID const & ) ; assign_function_type assign_function_value( &::SireID::IDOrSet< SireMol::SegID >::operator= ); IDOrSet_SegID__exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } IDOrSet_SegID__exposer.def( bp::self == bp::other< SireID::ID >() ); IDOrSet_SegID__exposer.def( bp::self == bp::self ); IDOrSet_SegID__exposer.def( bp::self == bp::other< SireMol::SegID >() ); { //::SireID::IDOrSet< SireMol::SegID >::toString typedef SireID::IDOrSet< SireMol::SegID > exported_class_t; typedef ::QString ( ::SireID::IDOrSet< SireMol::SegID >::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireID::IDOrSet< SireMol::SegID >::toString ); IDOrSet_SegID__exposer.def( "toString" , toString_function_value ); } { //::SireID::IDOrSet< SireMol::SegID >::typeName typedef SireID::IDOrSet< SireMol::SegID > exported_class_t; typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireID::IDOrSet< SireMol::SegID >::typeName ); IDOrSet_SegID__exposer.def( "typeName" , typeName_function_value ); } { //::SireID::IDOrSet< SireMol::SegID >::what typedef SireID::IDOrSet< SireMol::SegID > exported_class_t; typedef char const * ( ::SireID::IDOrSet< SireMol::SegID >::*what_function_type )( ) const; what_function_type what_function_value( &::SireID::IDOrSet< SireMol::SegID >::what ); IDOrSet_SegID__exposer.def( "what" , what_function_value ); } IDOrSet_SegID__exposer.staticmethod( "typeName" ); IDOrSet_SegID__exposer.def( "__copy__", &__copy__); IDOrSet_SegID__exposer.def( "__deepcopy__", &__copy__); IDOrSet_SegID__exposer.def( "clone", &__copy__); IDOrSet_SegID__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireID::IDOrSet<SireMol::SegID> >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); IDOrSet_SegID__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireID::IDOrSet<SireMol::SegID> >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); IDOrSet_SegID__exposer.def( "__str__", &__str__< ::SireID::IDOrSet<SireMol::SegID> > ); IDOrSet_SegID__exposer.def( "__repr__", &__str__< ::SireID::IDOrSet<SireMol::SegID> > ); } }
void register_SpecifyMol_class(){ { //::SireMol::SpecifyMol typedef bp::class_< SireMol::SpecifyMol, bp::bases< SireMol::MolID, SireID::ID > > SpecifyMol_exposer_t; SpecifyMol_exposer_t SpecifyMol_exposer = SpecifyMol_exposer_t( "SpecifyMol", "This class allow for the specification of specific\nmatching molecules\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") ); bp::scope SpecifyMol_scope( SpecifyMol_exposer ); SpecifyMol_exposer.def( bp::init< SireMol::MolID const & >(( bp::arg("molid") ), "Construct to match all of the molecules that match the\nID molid") ); SpecifyMol_exposer.def( bp::init< SireMol::MolID const &, int >(( bp::arg("molid"), bp::arg("i") ), "Construct to match the ith molecule that matches the ID molid") ); SpecifyMol_exposer.def( bp::init< SireMol::MolID const &, int, int >(( bp::arg("molid"), bp::arg("i"), bp::arg("j") ), "Construct to math the range of molecules from i to j that\nmatch the ID molid") ); SpecifyMol_exposer.def( bp::init< SireMol::SpecifyMol const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireMol::SpecifyMol::hash typedef ::uint ( ::SireMol::SpecifyMol::*hash_function_type)( ) const; hash_function_type hash_function_value( &::SireMol::SpecifyMol::hash ); SpecifyMol_exposer.def( "hash" , hash_function_value , "Hash this ID" ); } { //::SireMol::SpecifyMol::isNull typedef bool ( ::SireMol::SpecifyMol::*isNull_function_type)( ) const; isNull_function_type isNull_function_value( &::SireMol::SpecifyMol::isNull ); SpecifyMol_exposer.def( "isNull" , isNull_function_value , "Return whether or not this ID is null" ); } { //::SireMol::SpecifyMol::map typedef ::QList< SireMol::MolNum > ( ::SireMol::SpecifyMol::*map_function_type)( ::SireMol::Molecules const & ) const; map_function_type map_function_value( &::SireMol::SpecifyMol::map ); SpecifyMol_exposer.def( "map" , map_function_value , ( bp::arg("molecules") ) , "Map this ID to the list of molecule numbers that match" ); } { //::SireMol::SpecifyMol::map typedef ::QList< SireMol::MolNum > ( ::SireMol::SpecifyMol::*map_function_type)( ::SireMol::MoleculeGroup const & ) const; map_function_type map_function_value( &::SireMol::SpecifyMol::map ); SpecifyMol_exposer.def( "map" , map_function_value , ( bp::arg("molgroup") ) , "Map this ID to the list of molecule numbers that match" ); } { //::SireMol::SpecifyMol::map typedef ::QList< SireMol::MolNum > ( ::SireMol::SpecifyMol::*map_function_type)( ::SireMol::MolGroupsBase const & ) const; map_function_type map_function_value( &::SireMol::SpecifyMol::map ); SpecifyMol_exposer.def( "map" , map_function_value , ( bp::arg("molgroups") ) , "Map this ID to the list of molecule numbers that match" ); } SpecifyMol_exposer.def( bp::self != bp::self ); SpecifyMol_exposer.def( bp::self != bp::other< SireID::ID >() ); { //::SireMol::SpecifyMol::operator= typedef ::SireMol::SpecifyMol & ( ::SireMol::SpecifyMol::*assign_function_type)( ::SireMol::SpecifyMol const & ) ; assign_function_type assign_function_value( &::SireMol::SpecifyMol::operator= ); SpecifyMol_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } SpecifyMol_exposer.def( bp::self == bp::self ); SpecifyMol_exposer.def( bp::self == bp::other< SireID::ID >() ); { //::SireMol::SpecifyMol::toString typedef ::QString ( ::SireMol::SpecifyMol::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireMol::SpecifyMol::toString ); SpecifyMol_exposer.def( "toString" , toString_function_value , "Return a string representation of this ID" ); } { //::SireMol::SpecifyMol::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMol::SpecifyMol::typeName ); SpecifyMol_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireMol::SpecifyMol::what typedef char const * ( ::SireMol::SpecifyMol::*what_function_type)( ) const; what_function_type what_function_value( &::SireMol::SpecifyMol::what ); SpecifyMol_exposer.def( "what" , what_function_value , "" ); } SpecifyMol_exposer.staticmethod( "typeName" ); SpecifyMol_exposer.def( "__copy__", &__copy__); SpecifyMol_exposer.def( "__deepcopy__", &__copy__); SpecifyMol_exposer.def( "clone", &__copy__); SpecifyMol_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::SpecifyMol >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); SpecifyMol_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::SpecifyMol >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); SpecifyMol_exposer.def( "__str__", &__str__< ::SireMol::SpecifyMol > ); SpecifyMol_exposer.def( "__repr__", &__str__< ::SireMol::SpecifyMol > ); SpecifyMol_exposer.def( "__hash__", &::SireMol::SpecifyMol::hash ); } }
void register_Within_class(){ { //::SireMol::Within typedef bp::class_< SireMol::Within, bp::bases< SireMol::AtomID, SireID::ID > > Within_exposer_t; Within_exposer_t Within_exposer = Within_exposer_t( "Within", bp::init< >() ); bp::scope Within_scope( Within_exposer ); Within_exposer.def( bp::init< SireUnits::Dimension::Length, SireMaths::Vector const & >(( bp::arg("distance"), bp::arg("point") )) ); Within_exposer.def( bp::init< SireUnits::Dimension::Length, SireMol::AtomID const & >(( bp::arg("distance"), bp::arg("atomid") )) ); Within_exposer.def( bp::init< SireMol::Within const & >(( bp::arg("other") )) ); { //::SireMol::Within::hash typedef ::uint ( ::SireMol::Within::*hash_function_type )( ) const; hash_function_type hash_function_value( &::SireMol::Within::hash ); Within_exposer.def( "hash" , hash_function_value ); } { //::SireMol::Within::isNull typedef bool ( ::SireMol::Within::*isNull_function_type )( ) const; isNull_function_type isNull_function_value( &::SireMol::Within::isNull ); Within_exposer.def( "isNull" , isNull_function_value ); } { //::SireMol::Within::map typedef ::QList< SireMol::AtomIdx > ( ::SireMol::Within::*map_function_type )( ::SireMol::MolInfo const & ) const; map_function_type map_function_value( &::SireMol::Within::map ); Within_exposer.def( "map" , map_function_value , ( bp::arg("molinfo") ) ); } { //::SireMol::Within::map typedef ::QList< SireMol::AtomIdx > ( ::SireMol::Within::*map_function_type )( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ) const; map_function_type map_function_value( &::SireMol::Within::map ); Within_exposer.def( "map" , map_function_value , ( bp::arg("molview"), bp::arg("map") ) ); } Within_exposer.def( bp::self != bp::self ); { //::SireMol::Within::operator= typedef ::SireMol::Within & ( ::SireMol::Within::*assign_function_type )( ::SireMol::Within const & ) ; assign_function_type assign_function_value( &::SireMol::Within::operator= ); Within_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } Within_exposer.def( bp::self == bp::other< SireID::ID >() ); Within_exposer.def( bp::self == bp::self ); { //::SireMol::Within::toString typedef ::QString ( ::SireMol::Within::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireMol::Within::toString ); Within_exposer.def( "toString" , toString_function_value ); } { //::SireMol::Within::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMol::Within::typeName ); Within_exposer.def( "typeName" , typeName_function_value ); } { //::SireMol::Within::what typedef char const * ( ::SireMol::Within::*what_function_type )( ) const; what_function_type what_function_value( &::SireMol::Within::what ); Within_exposer.def( "what" , what_function_value ); } Within_exposer.staticmethod( "typeName" ); Within_exposer.def( "__copy__", &__copy__); Within_exposer.def( "__deepcopy__", &__copy__); Within_exposer.def( "clone", &__copy__); Within_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::Within >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Within_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::Within >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Within_exposer.def( "__str__", &__str__< ::SireMol::Within > ); Within_exposer.def( "__repr__", &__str__< ::SireMol::Within > ); } }
void register_CGsWithAtoms_class(){ { //::SireMol::CGsWithAtoms typedef bp::class_< SireMol::CGsWithAtoms, bp::bases< SireMol::CGID, SireID::ID > > CGsWithAtoms_exposer_t; CGsWithAtoms_exposer_t CGsWithAtoms_exposer = CGsWithAtoms_exposer_t( "CGsWithAtoms", bp::init< >() ); bp::scope CGsWithAtoms_scope( CGsWithAtoms_exposer ); CGsWithAtoms_exposer.def( bp::init< SireMol::AtomID const & >(( bp::arg("atomid") )) ); CGsWithAtoms_exposer.def( bp::init< SireMol::CGsWithAtoms const & >(( bp::arg("other") )) ); { //::SireMol::CGsWithAtoms::atomID typedef ::SireMol::AtomID const & ( ::SireMol::CGsWithAtoms::*atomID_function_type )( ) const; atomID_function_type atomID_function_value( &::SireMol::CGsWithAtoms::atomID ); CGsWithAtoms_exposer.def( "atomID" , atomID_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMol::CGsWithAtoms::hash typedef ::uint ( ::SireMol::CGsWithAtoms::*hash_function_type )( ) const; hash_function_type hash_function_value( &::SireMol::CGsWithAtoms::hash ); CGsWithAtoms_exposer.def( "hash" , hash_function_value ); } { //::SireMol::CGsWithAtoms::isNull typedef bool ( ::SireMol::CGsWithAtoms::*isNull_function_type )( ) const; isNull_function_type isNull_function_value( &::SireMol::CGsWithAtoms::isNull ); CGsWithAtoms_exposer.def( "isNull" , isNull_function_value ); } { //::SireMol::CGsWithAtoms::map typedef ::QList< SireMol::CGIdx > ( ::SireMol::CGsWithAtoms::*map_function_type )( ::SireMol::MolInfo const & ) const; map_function_type map_function_value( &::SireMol::CGsWithAtoms::map ); CGsWithAtoms_exposer.def( "map" , map_function_value , ( bp::arg("molinfo") ) ); } CGsWithAtoms_exposer.def( bp::self != bp::self ); { //::SireMol::CGsWithAtoms::operator= typedef ::SireMol::CGsWithAtoms & ( ::SireMol::CGsWithAtoms::*assign_function_type )( ::SireMol::CGsWithAtoms const & ) ; assign_function_type assign_function_value( &::SireMol::CGsWithAtoms::operator= ); CGsWithAtoms_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } CGsWithAtoms_exposer.def( bp::self == bp::other< SireID::ID >() ); CGsWithAtoms_exposer.def( bp::self == bp::self ); { //::SireMol::CGsWithAtoms::toString typedef ::QString ( ::SireMol::CGsWithAtoms::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireMol::CGsWithAtoms::toString ); CGsWithAtoms_exposer.def( "toString" , toString_function_value ); } { //::SireMol::CGsWithAtoms::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMol::CGsWithAtoms::typeName ); CGsWithAtoms_exposer.def( "typeName" , typeName_function_value ); } { //::SireMol::CGsWithAtoms::what typedef char const * ( ::SireMol::CGsWithAtoms::*what_function_type )( ) const; what_function_type what_function_value( &::SireMol::CGsWithAtoms::what ); CGsWithAtoms_exposer.def( "what" , what_function_value ); } CGsWithAtoms_exposer.staticmethod( "typeName" ); CGsWithAtoms_exposer.def( "__copy__", &__copy__); CGsWithAtoms_exposer.def( "__deepcopy__", &__copy__); CGsWithAtoms_exposer.def( "clone", &__copy__); CGsWithAtoms_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::CGsWithAtoms >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); CGsWithAtoms_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::CGsWithAtoms >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); CGsWithAtoms_exposer.def( "__str__", &__str__< ::SireMol::CGsWithAtoms > ); CGsWithAtoms_exposer.def( "__repr__", &__str__< ::SireMol::CGsWithAtoms > ); } }
void register_Number_class(){ { //::SireID::Number typedef bp::class_< SireID::Number, boost::noncopyable > Number_exposer_t; Number_exposer_t Number_exposer = Number_exposer_t( "Number", "This is the base class of all Number ID objects. A Number\nis used to provide an object with an identifying number.\nThis could be the number of a residue in a molecule, a\nuser-supplied number of a CutGroup in a molecule, or\nperhaps the automatic unique ID numbers of molecules,\nforcefields or molecule groups that are assigned by the\nprogram. The key point of a Number is to provide an ID\nthat can be queried and compared rapidly, and that\ndoes not change as the object is moved between different\ncontainers. Generally an object should keep its number\nthroughout its lifetime.\n\nAuthor: Christopher Woods\n", bp::no_init ); bp::scope Number_scope( Number_exposer ); { //::SireID::Number::hash typedef ::uint ( ::SireID::Number::*hash_function_type)( ) const; hash_function_type hash_function_value( &::SireID::Number::hash ); Number_exposer.def( "hash" , hash_function_value , "" ); } { //::SireID::Number::isNull typedef bool ( ::SireID::Number::*isNull_function_type)( ) const; isNull_function_type isNull_function_value( &::SireID::Number::isNull ); Number_exposer.def( "isNull" , isNull_function_value , "" ); } { //::SireID::Number::null typedef ::qint32 ( *null_function_type )( ); null_function_type null_function_value( &::SireID::Number::null ); Number_exposer.def( "null" , null_function_value , "" ); } { //::SireID::Number::value typedef ::qint32 ( ::SireID::Number::*value_function_type)( ) const; value_function_type value_function_value( &::SireID::Number::value ); Number_exposer.def( "value" , value_function_value , "" ); } Number_exposer.staticmethod( "null" ); Number_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireID::Number >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Number_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireID::Number >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Number_exposer.def( "__str__", &pvt_get_name); Number_exposer.def( "__repr__", &pvt_get_name); Number_exposer.def( "__hash__", &::SireID::Number::hash ); } }
void register_Product_class(){ { //::SireCAS::Product typedef bp::class_< SireCAS::Product, bp::bases< SireCAS::ExBase > > Product_exposer_t; Product_exposer_t Product_exposer = Product_exposer_t( "Product", bp::init< >() ); bp::scope Product_scope( Product_exposer ); Product_exposer.def( bp::init< SireCAS::Expression const &, SireCAS::Expression const & >(( bp::arg("ex0"), bp::arg("ex1") )) ); Product_exposer.def( bp::init< SireCAS::Expressions const & >(( bp::arg("expressions") )) ); Product_exposer.def( bp::init< SireCAS::Product const & >(( bp::arg("other") )) ); { //::SireCAS::Product::children typedef ::SireCAS::Expressions ( ::SireCAS::Product::*children_function_type )( ) const; children_function_type children_function_value( &::SireCAS::Product::children ); Product_exposer.def( "children" , children_function_value ); } { //::SireCAS::Product::conjugate typedef ::SireCAS::Expression ( ::SireCAS::Product::*conjugate_function_type )( ) const; conjugate_function_type conjugate_function_value( &::SireCAS::Product::conjugate ); Product_exposer.def( "conjugate" , conjugate_function_value ); } { //::SireCAS::Product::denominator typedef ::SireCAS::Product ( ::SireCAS::Product::*denominator_function_type )( ) const; denominator_function_type denominator_function_value( &::SireCAS::Product::denominator ); Product_exposer.def( "denominator" , denominator_function_value ); } { //::SireCAS::Product::differentiate typedef ::SireCAS::Expression ( ::SireCAS::Product::*differentiate_function_type )( ::SireCAS::Symbol const & ) const; differentiate_function_type differentiate_function_value( &::SireCAS::Product::differentiate ); Product_exposer.def( "differentiate" , differentiate_function_value , ( bp::arg("symbol") ) ); } { //::SireCAS::Product::evaluate typedef double ( ::SireCAS::Product::*evaluate_function_type )( ::SireCAS::Values const & ) const; evaluate_function_type evaluate_function_value( &::SireCAS::Product::evaluate ); Product_exposer.def( "evaluate" , evaluate_function_value , ( bp::arg("values") ) ); } { //::SireCAS::Product::evaluate typedef ::SireMaths::Complex ( ::SireCAS::Product::*evaluate_function_type )( ::SireCAS::ComplexValues const & ) const; evaluate_function_type evaluate_function_value( &::SireCAS::Product::evaluate ); Product_exposer.def( "evaluate" , evaluate_function_value , ( bp::arg("values") ) ); } { //::SireCAS::Product::expand typedef ::QList< SireCAS::Factor > ( ::SireCAS::Product::*expand_function_type )( ::SireCAS::Symbol const & ) const; expand_function_type expand_function_value( &::SireCAS::Product::expand ); Product_exposer.def( "expand" , expand_function_value , ( bp::arg("symbol") ) ); } { //::SireCAS::Product::functions typedef ::SireCAS::Functions ( ::SireCAS::Product::*functions_function_type )( ) const; functions_function_type functions_function_value( &::SireCAS::Product::functions ); Product_exposer.def( "functions" , functions_function_value ); } { //::SireCAS::Product::hash typedef ::uint ( ::SireCAS::Product::*hash_function_type )( ) const; hash_function_type hash_function_value( &::SireCAS::Product::hash ); Product_exposer.def( "hash" , hash_function_value ); } { //::SireCAS::Product::integrate typedef ::SireCAS::Expression ( ::SireCAS::Product::*integrate_function_type )( ::SireCAS::Symbol const & ) const; integrate_function_type integrate_function_value( &::SireCAS::Product::integrate ); Product_exposer.def( "integrate" , integrate_function_value , ( bp::arg("symbol") ) ); } { //::SireCAS::Product::isComplex typedef bool ( ::SireCAS::Product::*isComplex_function_type )( ) const; isComplex_function_type isComplex_function_value( &::SireCAS::Product::isComplex ); Product_exposer.def( "isComplex" , isComplex_function_value ); } { //::SireCAS::Product::isCompound typedef bool ( ::SireCAS::Product::*isCompound_function_type )( ) const; isCompound_function_type isCompound_function_value( &::SireCAS::Product::isCompound ); Product_exposer.def( "isCompound" , isCompound_function_value ); } { //::SireCAS::Product::isConstant typedef bool ( ::SireCAS::Product::*isConstant_function_type )( ) const; isConstant_function_type isConstant_function_value( &::SireCAS::Product::isConstant ); Product_exposer.def( "isConstant" , isConstant_function_value ); } { //::SireCAS::Product::isFunction typedef bool ( ::SireCAS::Product::*isFunction_function_type )( ::SireCAS::Symbol const & ) const; isFunction_function_type isFunction_function_value( &::SireCAS::Product::isFunction ); Product_exposer.def( "isFunction" , isFunction_function_value , ( bp::arg("arg0") ) ); } { //::SireCAS::Product::numerator typedef ::SireCAS::Product ( ::SireCAS::Product::*numerator_function_type )( ) const; numerator_function_type numerator_function_value( &::SireCAS::Product::numerator ); Product_exposer.def( "numerator" , numerator_function_value ); } Product_exposer.def( bp::self == bp::other< SireCAS::ExBase >() ); { //::SireCAS::Product::reduce typedef ::SireCAS::Expression ( ::SireCAS::Product::*reduce_function_type )( ) const; reduce_function_type reduce_function_value( &::SireCAS::Product::reduce ); Product_exposer.def( "reduce" , reduce_function_value ); } { //::SireCAS::Product::series typedef ::SireCAS::Expression ( ::SireCAS::Product::*series_function_type )( ::SireCAS::Symbol const &,int ) const; series_function_type series_function_value( &::SireCAS::Product::series ); Product_exposer.def( "series" , series_function_value , ( bp::arg("symbol"), bp::arg("n") ) ); } { //::SireCAS::Product::simplify typedef ::SireCAS::Expression ( ::SireCAS::Product::*simplify_function_type )( int ) const; simplify_function_type simplify_function_value( &::SireCAS::Product::simplify ); Product_exposer.def( "simplify" , simplify_function_value , ( bp::arg("options")=(int)(0) ) ); } { //::SireCAS::Product::substitute typedef ::SireCAS::Expression ( ::SireCAS::Product::*substitute_function_type )( ::SireCAS::Identities const & ) const; substitute_function_type substitute_function_value( &::SireCAS::Product::substitute ); Product_exposer.def( "substitute" , substitute_function_value , ( bp::arg("identities") ) ); } { //::SireCAS::Product::symbols typedef ::SireCAS::Symbols ( ::SireCAS::Product::*symbols_function_type )( ) const; symbols_function_type symbols_function_value( &::SireCAS::Product::symbols ); Product_exposer.def( "symbols" , symbols_function_value ); } { //::SireCAS::Product::toString typedef ::QString ( ::SireCAS::Product::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireCAS::Product::toString ); Product_exposer.def( "toString" , toString_function_value ); } { //::SireCAS::Product::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireCAS::Product::typeName ); Product_exposer.def( "typeName" , typeName_function_value ); } { //::SireCAS::Product::what typedef char const * ( ::SireCAS::Product::*what_function_type )( ) const; what_function_type what_function_value( &::SireCAS::Product::what ); Product_exposer.def( "what" , what_function_value ); } Product_exposer.staticmethod( "typeName" ); Product_exposer.def( "__copy__", &__copy__); Product_exposer.def( "__deepcopy__", &__copy__); Product_exposer.def( "clone", &__copy__); Product_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::Product >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Product_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::Product >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Product_exposer.def( "__str__", &__str__< ::SireCAS::Product > ); Product_exposer.def( "__repr__", &__str__< ::SireCAS::Product > ); } }
void register_ChainIdx_class(){ { //::SireMol::ChainIdx typedef bp::class_< SireMol::ChainIdx, bp::bases< SireMol::ChainID, SireID::ID, SireID::IndexBase > > ChainIdx_exposer_t; ChainIdx_exposer_t ChainIdx_exposer = ChainIdx_exposer_t( "ChainIdx", bp::init< >() ); bp::scope ChainIdx_scope( ChainIdx_exposer ); ChainIdx_exposer.def( bp::init< qint32 >(( bp::arg("idx") )) ); ChainIdx_exposer.def( bp::init< SireMol::ChainIdx const & >(( bp::arg("other") )) ); { //::SireMol::ChainIdx::hash typedef ::uint ( ::SireMol::ChainIdx::*hash_function_type )( ) const; hash_function_type hash_function_value( &::SireMol::ChainIdx::hash ); ChainIdx_exposer.def( "hash" , hash_function_value ); } { //::SireMol::ChainIdx::isNull typedef bool ( ::SireMol::ChainIdx::*isNull_function_type )( ) const; isNull_function_type isNull_function_value( &::SireMol::ChainIdx::isNull ); ChainIdx_exposer.def( "isNull" , isNull_function_value ); } { //::SireMol::ChainIdx::map typedef ::QList< SireMol::ChainIdx > ( ::SireMol::ChainIdx::*map_function_type )( ::SireMol::MolInfo const & ) const; map_function_type map_function_value( &::SireMol::ChainIdx::map ); ChainIdx_exposer.def( "map" , map_function_value , ( bp::arg("molinfo") ) ); } { //::SireMol::ChainIdx::null typedef ::SireMol::ChainIdx ( *null_function_type )( ); null_function_type null_function_value( &::SireMol::ChainIdx::null ); ChainIdx_exposer.def( "null" , null_function_value ); } { //::SireMol::ChainIdx::operator= typedef ::SireMol::ChainIdx & ( ::SireMol::ChainIdx::*assign_function_type )( ::SireMol::ChainIdx const & ) ; assign_function_type assign_function_value( &::SireMol::ChainIdx::operator= ); ChainIdx_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } { //::SireMol::ChainIdx::toString typedef ::QString ( ::SireMol::ChainIdx::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireMol::ChainIdx::toString ); ChainIdx_exposer.def( "toString" , toString_function_value ); } { //::SireMol::ChainIdx::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMol::ChainIdx::typeName ); ChainIdx_exposer.def( "typeName" , typeName_function_value ); } { //::SireMol::ChainIdx::what typedef char const * ( ::SireMol::ChainIdx::*what_function_type )( ) const; what_function_type what_function_value( &::SireMol::ChainIdx::what ); ChainIdx_exposer.def( "what" , what_function_value ); } ChainIdx_exposer.staticmethod( "null" ); ChainIdx_exposer.staticmethod( "typeName" ); ChainIdx_exposer.def( "__copy__", &__copy__); ChainIdx_exposer.def( "__deepcopy__", &__copy__); ChainIdx_exposer.def( "clone", &__copy__); ChainIdx_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::ChainIdx >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); ChainIdx_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::ChainIdx >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); ChainIdx_exposer.def( "__str__", &__str__< ::SireMol::ChainIdx > ); ChainIdx_exposer.def( "__repr__", &__str__< ::SireMol::ChainIdx > ); } }
void register_MonitorName_class(){ { //::SireSystem::MonitorName typedef bp::class_< SireSystem::MonitorName, bp::bases< SireSystem::MonitorID, SireID::ID, SireID::Name > > MonitorName_exposer_t; MonitorName_exposer_t MonitorName_exposer = MonitorName_exposer_t( "MonitorName", "This class holds the name of a simulation system\n\nAuthor: Christopher Woods\n", bp::init< >("") ); bp::scope MonitorName_scope( MonitorName_exposer ); MonitorName_exposer.def( bp::init< QString const & >(( bp::arg("name") ), "") ); MonitorName_exposer.def( bp::init< SireSystem::MonitorName const & >(( bp::arg("other") ), "") ); { //::SireSystem::MonitorName::hash typedef ::uint ( ::SireSystem::MonitorName::*hash_function_type)( ) const; hash_function_type hash_function_value( &::SireSystem::MonitorName::hash ); MonitorName_exposer.def( "hash" , hash_function_value , "" ); } { //::SireSystem::MonitorName::isNull typedef bool ( ::SireSystem::MonitorName::*isNull_function_type)( ) const; isNull_function_type isNull_function_value( &::SireSystem::MonitorName::isNull ); MonitorName_exposer.def( "isNull" , isNull_function_value , "" ); } { //::SireSystem::MonitorName::map typedef ::QList< SireSystem::MonitorName > ( ::SireSystem::MonitorName::*map_function_type)( ::SireSystem::SystemMonitors const & ) const; map_function_type map_function_value( &::SireSystem::MonitorName::map ); MonitorName_exposer.def( "map" , map_function_value , ( bp::arg("monitors") ) , "" ); } MonitorName_exposer.def( bp::self != bp::self ); { //::SireSystem::MonitorName::operator= typedef ::SireSystem::MonitorName & ( ::SireSystem::MonitorName::*assign_function_type)( ::SireSystem::MonitorName const & ) ; assign_function_type assign_function_value( &::SireSystem::MonitorName::operator= ); MonitorName_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } MonitorName_exposer.def( bp::self == bp::other< SireID::ID >() ); MonitorName_exposer.def( bp::self == bp::self ); { //::SireSystem::MonitorName::toString typedef ::QString ( ::SireSystem::MonitorName::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireSystem::MonitorName::toString ); MonitorName_exposer.def( "toString" , toString_function_value , "" ); } { //::SireSystem::MonitorName::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireSystem::MonitorName::typeName ); MonitorName_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireSystem::MonitorName::what typedef char const * ( ::SireSystem::MonitorName::*what_function_type)( ) const; what_function_type what_function_value( &::SireSystem::MonitorName::what ); MonitorName_exposer.def( "what" , what_function_value , "" ); } MonitorName_exposer.staticmethod( "typeName" ); MonitorName_exposer.def( "__copy__", &__copy__); MonitorName_exposer.def( "__deepcopy__", &__copy__); MonitorName_exposer.def( "clone", &__copy__); MonitorName_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireSystem::MonitorName >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); MonitorName_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireSystem::MonitorName >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); MonitorName_exposer.def( "__str__", &__str__< ::SireSystem::MonitorName > ); MonitorName_exposer.def( "__repr__", &__str__< ::SireSystem::MonitorName > ); MonitorName_exposer.def( "__hash__", &::SireSystem::MonitorName::hash ); } }
void register_MolResNum_class(){ { //::SireMol::MolResNum typedef bp::class_< SireMol::MolResNum, bp::bases< SireMol::ResID, SireID::ID > > MolResNum_exposer_t; MolResNum_exposer_t MolResNum_exposer = MolResNum_exposer_t( "MolResNum", bp::init< >() ); bp::scope MolResNum_scope( MolResNum_exposer ); MolResNum_exposer.def( bp::init< SireMol::MolNum const &, SireMol::ResNum const & >(( bp::arg("molnum"), bp::arg("resnum") )) ); MolResNum_exposer.def( bp::init< SireMol::ResNum const &, SireMol::MolNum const & >(( bp::arg("resnum"), bp::arg("molnum") )) ); MolResNum_exposer.def( bp::init< SireMol::MolResNum const & >(( bp::arg("other") )) ); { //::SireMol::MolResNum::hash typedef ::uint ( ::SireMol::MolResNum::*hash_function_type )( ) const; hash_function_type hash_function_value( &::SireMol::MolResNum::hash ); MolResNum_exposer.def( "hash" , hash_function_value ); } { //::SireMol::MolResNum::isNull typedef bool ( ::SireMol::MolResNum::*isNull_function_type )( ) const; isNull_function_type isNull_function_value( &::SireMol::MolResNum::isNull ); MolResNum_exposer.def( "isNull" , isNull_function_value ); } { //::SireMol::MolResNum::map typedef ::QList< SireMol::ResIdx > ( ::SireMol::MolResNum::*map_function_type )( ::SireMol::MolInfo const & ) const; map_function_type map_function_value( &::SireMol::MolResNum::map ); MolResNum_exposer.def( "map" , map_function_value , ( bp::arg("molinfo") ) ); } { //::SireMol::MolResNum::molNum typedef ::SireMol::MolNum const & ( ::SireMol::MolResNum::*molNum_function_type )( ) const; molNum_function_type molNum_function_value( &::SireMol::MolResNum::molNum ); MolResNum_exposer.def( "molNum" , molNum_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } MolResNum_exposer.def( bp::self != bp::self ); { //::SireMol::MolResNum::operator= typedef ::SireMol::MolResNum & ( ::SireMol::MolResNum::*assign_function_type )( ::SireMol::MolResNum const & ) ; assign_function_type assign_function_value( &::SireMol::MolResNum::operator= ); MolResNum_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } MolResNum_exposer.def( bp::self == bp::other< SireID::ID >() ); MolResNum_exposer.def( bp::self == bp::self ); { //::SireMol::MolResNum::resNum typedef ::SireMol::ResNum const & ( ::SireMol::MolResNum::*resNum_function_type )( ) const; resNum_function_type resNum_function_value( &::SireMol::MolResNum::resNum ); MolResNum_exposer.def( "resNum" , resNum_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMol::MolResNum::selectAllFrom typedef ::QHash< SireMol::MolNum, SireMol::Selector< SireMol::Residue > > ( ::SireMol::MolResNum::*selectAllFrom_function_type )( ::SireMol::Molecules const &,::SireBase::PropertyMap const & ) const; selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::MolResNum::selectAllFrom ); MolResNum_exposer.def( "selectAllFrom" , selectAllFrom_function_value , ( bp::arg("molecules"), bp::arg("map")=SireBase::PropertyMap() ) ); } { //::SireMol::MolResNum::selectAllFrom typedef ::QHash< SireMol::MolNum, SireMol::Selector< SireMol::Residue > > ( ::SireMol::MolResNum::*selectAllFrom_function_type )( ::SireMol::MoleculeGroup const &,::SireBase::PropertyMap const & ) const; selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::MolResNum::selectAllFrom ); MolResNum_exposer.def( "selectAllFrom" , selectAllFrom_function_value , ( bp::arg("molgroup"), bp::arg("map")=SireBase::PropertyMap() ) ); } { //::SireMol::MolResNum::selectAllFrom typedef ::QHash< SireMol::MolNum, SireMol::Selector< SireMol::Residue > > ( ::SireMol::MolResNum::*selectAllFrom_function_type )( ::SireMol::MolGroupsBase const &,::SireBase::PropertyMap const & ) const; selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::MolResNum::selectAllFrom ); MolResNum_exposer.def( "selectAllFrom" , selectAllFrom_function_value , ( bp::arg("molgroups"), bp::arg("map")=SireBase::PropertyMap() ) ); } { //::SireMol::MolResNum::toString typedef ::QString ( ::SireMol::MolResNum::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireMol::MolResNum::toString ); MolResNum_exposer.def( "toString" , toString_function_value ); } { //::SireMol::MolResNum::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMol::MolResNum::typeName ); MolResNum_exposer.def( "typeName" , typeName_function_value ); } { //::SireMol::MolResNum::what typedef char const * ( ::SireMol::MolResNum::*what_function_type )( ) const; what_function_type what_function_value( &::SireMol::MolResNum::what ); MolResNum_exposer.def( "what" , what_function_value ); } MolResNum_exposer.staticmethod( "typeName" ); MolResNum_exposer.def( "__copy__", &__copy__); MolResNum_exposer.def( "__deepcopy__", &__copy__); MolResNum_exposer.def( "clone", &__copy__); MolResNum_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::MolResNum >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); MolResNum_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::MolResNum >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); MolResNum_exposer.def( "__str__", &__str__< ::SireMol::MolResNum > ); MolResNum_exposer.def( "__repr__", &__str__< ::SireMol::MolResNum > ); } }
void register_IntegerPower_class(){ { //::SireCAS::IntegerPower typedef bp::class_< SireCAS::IntegerPower, bp::bases< SireCAS::PowerFunction, SireCAS::ExBase > > IntegerPower_exposer_t; IntegerPower_exposer_t IntegerPower_exposer = IntegerPower_exposer_t( "IntegerPower", bp::init< >() ); bp::scope IntegerPower_scope( IntegerPower_exposer ); IntegerPower_exposer.def( bp::init< SireCAS::Expression const &, int >(( bp::arg("expression"), bp::arg("power") )) ); IntegerPower_exposer.def( bp::init< SireCAS::IntegerPower const & >(( bp::arg("other") )) ); { //::SireCAS::IntegerPower::evaluate typedef double ( ::SireCAS::IntegerPower::*evaluate_function_type )( ::SireCAS::Values const & ) const; evaluate_function_type evaluate_function_value( &::SireCAS::IntegerPower::evaluate ); IntegerPower_exposer.def( "evaluate" , evaluate_function_value , ( bp::arg("values") ) ); } { //::SireCAS::IntegerPower::evaluate typedef ::SireMaths::Complex ( ::SireCAS::IntegerPower::*evaluate_function_type )( ::SireCAS::ComplexValues const & ) const; evaluate_function_type evaluate_function_value( &::SireCAS::IntegerPower::evaluate ); IntegerPower_exposer.def( "evaluate" , evaluate_function_value , ( bp::arg("values") ) ); } { //::SireCAS::IntegerPower::hash typedef ::uint ( ::SireCAS::IntegerPower::*hash_function_type )( ) const; hash_function_type hash_function_value( &::SireCAS::IntegerPower::hash ); IntegerPower_exposer.def( "hash" , hash_function_value ); } IntegerPower_exposer.def( bp::self == bp::other< SireCAS::ExBase >() ); { //::SireCAS::IntegerPower::power typedef ::SireCAS::Expression ( ::SireCAS::IntegerPower::*power_function_type )( ) const; power_function_type power_function_value( &::SireCAS::IntegerPower::power ); IntegerPower_exposer.def( "power" , power_function_value ); } { //::SireCAS::IntegerPower::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireCAS::IntegerPower::typeName ); IntegerPower_exposer.def( "typeName" , typeName_function_value ); } { //::SireCAS::IntegerPower::what typedef char const * ( ::SireCAS::IntegerPower::*what_function_type )( ) const; what_function_type what_function_value( &::SireCAS::IntegerPower::what ); IntegerPower_exposer.def( "what" , what_function_value ); } IntegerPower_exposer.staticmethod( "typeName" ); IntegerPower_exposer.def( "__copy__", &__copy__); IntegerPower_exposer.def( "__deepcopy__", &__copy__); IntegerPower_exposer.def( "clone", &__copy__); IntegerPower_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::IntegerPower >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); IntegerPower_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::IntegerPower >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); IntegerPower_exposer.def( "__str__", &__str__< ::SireCAS::IntegerPower > ); IntegerPower_exposer.def( "__repr__", &__str__< ::SireCAS::IntegerPower > ); } }
void register_Name_class(){ { //::SireID::Name typedef bp::class_< SireID::Name, boost::noncopyable > Name_exposer_t; Name_exposer_t Name_exposer = Name_exposer_t( "Name", bp::no_init ); bp::scope Name_scope( Name_exposer ); { //::SireID::Name::hash typedef ::uint ( ::SireID::Name::*hash_function_type )( ) const; hash_function_type hash_function_value( &::SireID::Name::hash ); Name_exposer.def( "hash" , hash_function_value ); } { //::SireID::Name::isCaseSensitive typedef bool ( ::SireID::Name::*isCaseSensitive_function_type )( ) const; isCaseSensitive_function_type isCaseSensitive_function_value( &::SireID::Name::isCaseSensitive ); Name_exposer.def( "isCaseSensitive" , isCaseSensitive_function_value ); } { //::SireID::Name::isEmpty typedef bool ( ::SireID::Name::*isEmpty_function_type )( ) const; isEmpty_function_type isEmpty_function_value( &::SireID::Name::isEmpty ); Name_exposer.def( "isEmpty" , isEmpty_function_value ); } { //::SireID::Name::isNull typedef bool ( ::SireID::Name::*isNull_function_type )( ) const; isNull_function_type isNull_function_value( &::SireID::Name::isNull ); Name_exposer.def( "isNull" , isNull_function_value ); } { //::SireID::Name::value typedef ::QString const & ( ::SireID::Name::*value_function_type )( ) const; value_function_type value_function_value( &::SireID::Name::value ); Name_exposer.def( "value" , value_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } Name_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireID::Name >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Name_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireID::Name >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Name_exposer.def( "__str__", &pvt_get_name); Name_exposer.def( "__repr__", &pvt_get_name); } }
void register_MolWithResID_class(){ { //::SireMol::MolWithResID typedef bp::class_< SireMol::MolWithResID, bp::bases< SireMol::MolID, SireID::ID > > MolWithResID_exposer_t; MolWithResID_exposer_t MolWithResID_exposer = MolWithResID_exposer_t( "MolWithResID", bp::init< >() ); bp::scope MolWithResID_scope( MolWithResID_exposer ); MolWithResID_exposer.def( bp::init< QString const & >(( bp::arg("resname") )) ); MolWithResID_exposer.def( bp::init< int >(( bp::arg("resnum") )) ); MolWithResID_exposer.def( bp::init< SireMol::ResID const & >(( bp::arg("resid") )) ); MolWithResID_exposer.def( bp::init< QString const &, SireID::CaseSensitivity >(( bp::arg("resname"), bp::arg("case_sensitivity") )) ); MolWithResID_exposer.def( bp::init< SireMol::MolWithResID const & >(( bp::arg("other") )) ); { //::SireMol::MolWithResID::hash typedef ::uint ( ::SireMol::MolWithResID::*hash_function_type )( ) const; hash_function_type hash_function_value( &::SireMol::MolWithResID::hash ); MolWithResID_exposer.def( "hash" , hash_function_value ); } { //::SireMol::MolWithResID::isNull typedef bool ( ::SireMol::MolWithResID::*isNull_function_type )( ) const; isNull_function_type isNull_function_value( &::SireMol::MolWithResID::isNull ); MolWithResID_exposer.def( "isNull" , isNull_function_value ); } { //::SireMol::MolWithResID::map typedef ::QList< SireMol::MolNum > ( ::SireMol::MolWithResID::*map_function_type )( ::SireMol::Molecules const & ) const; map_function_type map_function_value( &::SireMol::MolWithResID::map ); MolWithResID_exposer.def( "map" , map_function_value , ( bp::arg("molecules") ) ); } { //::SireMol::MolWithResID::map typedef ::QList< SireMol::MolNum > ( ::SireMol::MolWithResID::*map_function_type )( ::SireMol::MoleculeGroup const & ) const; map_function_type map_function_value( &::SireMol::MolWithResID::map ); MolWithResID_exposer.def( "map" , map_function_value , ( bp::arg("molgroup") ) ); } { //::SireMol::MolWithResID::map typedef ::QList< SireMol::MolNum > ( ::SireMol::MolWithResID::*map_function_type )( ::SireMol::MolGroupsBase const & ) const; map_function_type map_function_value( &::SireMol::MolWithResID::map ); MolWithResID_exposer.def( "map" , map_function_value , ( bp::arg("molgroups") ) ); } MolWithResID_exposer.def( bp::self != bp::self ); { //::SireMol::MolWithResID::operator= typedef ::SireMol::MolWithResID & ( ::SireMol::MolWithResID::*assign_function_type )( ::SireMol::MolWithResID const & ) ; assign_function_type assign_function_value( &::SireMol::MolWithResID::operator= ); MolWithResID_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } MolWithResID_exposer.def( bp::self == bp::other< SireID::ID >() ); MolWithResID_exposer.def( bp::self == bp::self ); { //::SireMol::MolWithResID::resID typedef ::SireMol::ResID const & ( ::SireMol::MolWithResID::*resID_function_type )( ) const; resID_function_type resID_function_value( &::SireMol::MolWithResID::resID ); MolWithResID_exposer.def( "resID" , resID_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMol::MolWithResID::toString typedef ::QString ( ::SireMol::MolWithResID::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireMol::MolWithResID::toString ); MolWithResID_exposer.def( "toString" , toString_function_value ); } { //::SireMol::MolWithResID::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMol::MolWithResID::typeName ); MolWithResID_exposer.def( "typeName" , typeName_function_value ); } { //::SireMol::MolWithResID::what typedef char const * ( ::SireMol::MolWithResID::*what_function_type )( ) const; what_function_type what_function_value( &::SireMol::MolWithResID::what ); MolWithResID_exposer.def( "what" , what_function_value ); } MolWithResID_exposer.staticmethod( "typeName" ); MolWithResID_exposer.def( "__copy__", &__copy__); MolWithResID_exposer.def( "__deepcopy__", &__copy__); MolWithResID_exposer.def( "clone", &__copy__); MolWithResID_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::MolWithResID >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); MolWithResID_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::MolWithResID >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); MolWithResID_exposer.def( "__str__", &__str__< ::SireMol::MolWithResID > ); MolWithResID_exposer.def( "__repr__", &__str__< ::SireMol::MolWithResID > ); } }
void register_Condition_class(){ { //::SireCAS::Condition typedef bp::class_< SireCAS::Condition, bp::bases< SireCAS::ExBase >, boost::noncopyable > Condition_exposer_t; Condition_exposer_t Condition_exposer = Condition_exposer_t( "Condition", bp::no_init ); bp::scope Condition_scope( Condition_exposer ); { //::SireCAS::Condition::alwaysFalse typedef bool ( ::SireCAS::Condition::*alwaysFalse_function_type )( ) const; alwaysFalse_function_type alwaysFalse_function_value( &::SireCAS::Condition::alwaysFalse ); Condition_exposer.def( "alwaysFalse" , alwaysFalse_function_value ); } { //::SireCAS::Condition::alwaysTrue typedef bool ( ::SireCAS::Condition::*alwaysTrue_function_type )( ) const; alwaysTrue_function_type alwaysTrue_function_value( &::SireCAS::Condition::alwaysTrue ); Condition_exposer.def( "alwaysTrue" , alwaysTrue_function_value ); } { //::SireCAS::Condition::children typedef ::SireCAS::Expressions ( ::SireCAS::Condition::*children_function_type )( ) const; children_function_type children_function_value( &::SireCAS::Condition::children ); Condition_exposer.def( "children" , children_function_value ); } { //::SireCAS::Condition::conjugate typedef ::SireCAS::Expression ( ::SireCAS::Condition::*conjugate_function_type )( ) const; conjugate_function_type conjugate_function_value( &::SireCAS::Condition::conjugate ); Condition_exposer.def( "conjugate" , conjugate_function_value ); } { //::SireCAS::Condition::differentiate typedef ::SireCAS::Expression ( ::SireCAS::Condition::*differentiate_function_type )( ::SireCAS::Symbol const & ) const; differentiate_function_type differentiate_function_value( &::SireCAS::Condition::differentiate ); Condition_exposer.def( "differentiate" , differentiate_function_value , ( bp::arg("symbol") ) ); } { //::SireCAS::Condition::evaluate typedef double ( ::SireCAS::Condition::*evaluate_function_type )( ::SireCAS::Values const & ) const; evaluate_function_type evaluate_function_value( &::SireCAS::Condition::evaluate ); Condition_exposer.def( "evaluate" , evaluate_function_value , ( bp::arg("values") ) ); } { //::SireCAS::Condition::evaluate typedef ::SireMaths::Complex ( ::SireCAS::Condition::*evaluate_function_type )( ::SireCAS::ComplexValues const & ) const; evaluate_function_type evaluate_function_value( &::SireCAS::Condition::evaluate ); Condition_exposer.def( "evaluate" , evaluate_function_value , ( bp::arg("values") ) ); } { //::SireCAS::Condition::evaluateCondition typedef bool ( ::SireCAS::Condition::*evaluateCondition_function_type )( ::SireCAS::Values const & ) const; evaluateCondition_function_type evaluateCondition_function_value( &::SireCAS::Condition::evaluateCondition ); Condition_exposer.def( "evaluateCondition" , evaluateCondition_function_value , ( bp::arg("values") ) ); } { //::SireCAS::Condition::evaluateCondition typedef bool ( ::SireCAS::Condition::*evaluateCondition_function_type )( ::SireCAS::ComplexValues const & ) const; evaluateCondition_function_type evaluateCondition_function_value( &::SireCAS::Condition::evaluateCondition ); Condition_exposer.def( "evaluateCondition" , evaluateCondition_function_value , ( bp::arg("values") ) ); } { //::SireCAS::Condition::expand typedef ::QList< SireCAS::Factor > ( ::SireCAS::Condition::*expand_function_type )( ::SireCAS::Symbol const & ) const; expand_function_type expand_function_value( &::SireCAS::Condition::expand ); Condition_exposer.def( "expand" , expand_function_value , ( bp::arg("symbol") ) ); } { //::SireCAS::Condition::functions typedef ::SireCAS::Functions ( ::SireCAS::Condition::*functions_function_type )( ) const; functions_function_type functions_function_value( &::SireCAS::Condition::functions ); Condition_exposer.def( "functions" , functions_function_value ); } { //::SireCAS::Condition::hash typedef ::uint ( ::SireCAS::Condition::*hash_function_type )( ) const; hash_function_type hash_function_value( &::SireCAS::Condition::hash ); Condition_exposer.def( "hash" , hash_function_value ); } { //::SireCAS::Condition::integrate typedef ::SireCAS::Expression ( ::SireCAS::Condition::*integrate_function_type )( ::SireCAS::Symbol const & ) const; integrate_function_type integrate_function_value( &::SireCAS::Condition::integrate ); Condition_exposer.def( "integrate" , integrate_function_value , ( bp::arg("symbol") ) ); } { //::SireCAS::Condition::isComplex typedef bool ( ::SireCAS::Condition::*isComplex_function_type )( ) const; isComplex_function_type isComplex_function_value( &::SireCAS::Condition::isComplex ); Condition_exposer.def( "isComplex" , isComplex_function_value ); } { //::SireCAS::Condition::isCompound typedef bool ( ::SireCAS::Condition::*isCompound_function_type )( ) const; isCompound_function_type isCompound_function_value( &::SireCAS::Condition::isCompound ); Condition_exposer.def( "isCompound" , isCompound_function_value ); } { //::SireCAS::Condition::isConstant typedef bool ( ::SireCAS::Condition::*isConstant_function_type )( ) const; isConstant_function_type isConstant_function_value( &::SireCAS::Condition::isConstant ); Condition_exposer.def( "isConstant" , isConstant_function_value ); } { //::SireCAS::Condition::isFunction typedef bool ( ::SireCAS::Condition::*isFunction_function_type )( ::SireCAS::Symbol const & ) const; isFunction_function_type isFunction_function_value( &::SireCAS::Condition::isFunction ); Condition_exposer.def( "isFunction" , isFunction_function_value , ( bp::arg("arg0") ) ); } { //::SireCAS::Condition::isNull typedef bool ( ::SireCAS::Condition::*isNull_function_type )( ) const; isNull_function_type isNull_function_value( &::SireCAS::Condition::isNull ); Condition_exposer.def( "isNull" , isNull_function_value ); } { //::SireCAS::Condition::leftHandSide typedef ::SireCAS::Expression const & ( ::SireCAS::Condition::*leftHandSide_function_type )( ) const; leftHandSide_function_type leftHandSide_function_value( &::SireCAS::Condition::leftHandSide ); Condition_exposer.def( "leftHandSide" , leftHandSide_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireCAS::Condition::rightHandSide typedef ::SireCAS::Expression const & ( ::SireCAS::Condition::*rightHandSide_function_type )( ) const; rightHandSide_function_type rightHandSide_function_value( &::SireCAS::Condition::rightHandSide ); Condition_exposer.def( "rightHandSide" , rightHandSide_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireCAS::Condition::simplify typedef ::SireCAS::Expression ( ::SireCAS::Condition::*simplify_function_type )( int ) const; simplify_function_type simplify_function_value( &::SireCAS::Condition::simplify ); Condition_exposer.def( "simplify" , simplify_function_value , ( bp::arg("options")=(int)(0) ) ); } { //::SireCAS::Condition::substitute typedef ::SireCAS::Expression ( ::SireCAS::Condition::*substitute_function_type )( ::SireCAS::Identities const & ) const; substitute_function_type substitute_function_value( &::SireCAS::Condition::substitute ); Condition_exposer.def( "substitute" , substitute_function_value , ( bp::arg("identities") ) ); } { //::SireCAS::Condition::symbols typedef ::SireCAS::Symbols ( ::SireCAS::Condition::*symbols_function_type )( ) const; symbols_function_type symbols_function_value( &::SireCAS::Condition::symbols ); Condition_exposer.def( "symbols" , symbols_function_value ); } { //::SireCAS::Condition::toString typedef ::QString ( ::SireCAS::Condition::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireCAS::Condition::toString ); Condition_exposer.def( "toString" , toString_function_value ); } { //::SireCAS::Condition::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireCAS::Condition::typeName ); Condition_exposer.def( "typeName" , typeName_function_value ); } Condition_exposer.staticmethod( "typeName" ); Condition_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::Condition >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Condition_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::Condition >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Condition_exposer.def( "__str__", &__str__< ::SireCAS::Condition > ); Condition_exposer.def( "__repr__", &__str__< ::SireCAS::Condition > ); } }
void register_Specify_SegID__class(){ { //::SireID::Specify< SireMol::SegID > typedef bp::class_< SireID::Specify< SireMol::SegID >, bp::bases< SireMol::SegID, SireID::ID > > Specify_SegID__exposer_t; Specify_SegID__exposer_t Specify_SegID__exposer = Specify_SegID__exposer_t( "Specify_SegID_", bp::init< >() ); bp::scope Specify_SegID__scope( Specify_SegID__exposer ); Specify_SegID__exposer.def( bp::init< SireMol::SegID const &, qint32 >(( bp::arg("id"), bp::arg("i") )) ); Specify_SegID__exposer.def( bp::init< SireMol::SegID const &, qint32, qint32 >(( bp::arg("id"), bp::arg("i"), bp::arg("j") )) ); Specify_SegID__exposer.def( bp::init< SireID::Specify< SireMol::SegID > const & >(( bp::arg("other") )) ); { //::SireID::Specify< SireMol::SegID >::hash typedef SireID::Specify< SireMol::SegID > exported_class_t; typedef ::uint ( ::SireID::Specify< SireMol::SegID >::*hash_function_type )( ) const; hash_function_type hash_function_value( &::SireID::Specify< SireMol::SegID >::hash ); Specify_SegID__exposer.def( "hash" , hash_function_value ); } { //::SireID::Specify< SireMol::SegID >::isNull typedef SireID::Specify< SireMol::SegID > exported_class_t; typedef bool ( ::SireID::Specify< SireMol::SegID >::*isNull_function_type )( ) const; isNull_function_type isNull_function_value( &::SireID::Specify< SireMol::SegID >::isNull ); Specify_SegID__exposer.def( "isNull" , isNull_function_value ); } { //::SireID::Specify< SireMol::SegID >::map typedef SireID::Specify< SireMol::SegID > exported_class_t; typedef ::QList< SireMol::SegIdx > ( ::SireID::Specify< SireMol::SegID >::*map_function_type )( ::SireMol::MolInfo const & ) const; map_function_type map_function_value( &::SireID::Specify< SireMol::SegID >::map ); Specify_SegID__exposer.def( "map" , map_function_value , ( bp::arg("obj") ) ); } Specify_SegID__exposer.def( bp::self != bp::self ); Specify_SegID__exposer.def( bp::self != bp::other< SireID::ID >() ); { //::SireID::Specify< SireMol::SegID >::operator() typedef SireID::Specify< SireMol::SegID > exported_class_t; typedef ::SireID::Specify< SireMol::SegID > ( ::SireID::Specify< SireMol::SegID >::*__call___function_type )( int ) const; __call___function_type __call___function_value( &::SireID::Specify< SireMol::SegID >::operator() ); Specify_SegID__exposer.def( "__call__" , __call___function_value , ( bp::arg("i") ) ); } { //::SireID::Specify< SireMol::SegID >::operator() typedef SireID::Specify< SireMol::SegID > exported_class_t; typedef ::SireID::Specify< SireMol::SegID > ( ::SireID::Specify< SireMol::SegID >::*__call___function_type )( int,int ) const; __call___function_type __call___function_value( &::SireID::Specify< SireMol::SegID >::operator() ); Specify_SegID__exposer.def( "__call__" , __call___function_value , ( bp::arg("i"), bp::arg("j") ) ); } { //::SireID::Specify< SireMol::SegID >::operator= typedef SireID::Specify< SireMol::SegID > exported_class_t; typedef ::SireID::Specify< SireMol::SegID > & ( ::SireID::Specify< SireMol::SegID >::*assign_function_type )( ::SireID::Specify< SireMol::SegID > const & ) ; assign_function_type assign_function_value( &::SireID::Specify< SireMol::SegID >::operator= ); Specify_SegID__exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } Specify_SegID__exposer.def( bp::self == bp::self ); Specify_SegID__exposer.def( bp::self == bp::other< SireID::ID >() ); { //::SireID::Specify< SireMol::SegID >::operator[] typedef SireID::Specify< SireMol::SegID > exported_class_t; typedef ::SireID::Specify< SireMol::SegID > ( ::SireID::Specify< SireMol::SegID >::*__getitem___function_type )( int ) const; __getitem___function_type __getitem___function_value( &::SireID::Specify< SireMol::SegID >::operator[] ); Specify_SegID__exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("i") ) ); } { //::SireID::Specify< SireMol::SegID >::toString typedef SireID::Specify< SireMol::SegID > exported_class_t; typedef ::QString ( ::SireID::Specify< SireMol::SegID >::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireID::Specify< SireMol::SegID >::toString ); Specify_SegID__exposer.def( "toString" , toString_function_value ); } { //::SireID::Specify< SireMol::SegID >::typeName typedef SireID::Specify< SireMol::SegID > exported_class_t; typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireID::Specify< SireMol::SegID >::typeName ); Specify_SegID__exposer.def( "typeName" , typeName_function_value ); } { //::SireID::Specify< SireMol::SegID >::what typedef SireID::Specify< SireMol::SegID > exported_class_t; typedef char const * ( ::SireID::Specify< SireMol::SegID >::*what_function_type )( ) const; what_function_type what_function_value( &::SireID::Specify< SireMol::SegID >::what ); Specify_SegID__exposer.def( "what" , what_function_value ); } Specify_SegID__exposer.staticmethod( "typeName" ); Specify_SegID__exposer.def( "__copy__", &__copy__); Specify_SegID__exposer.def( "__deepcopy__", &__copy__); Specify_SegID__exposer.def( "clone", &__copy__); Specify_SegID__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireID::Specify<SireMol::SegID> >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Specify_SegID__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireID::Specify<SireMol::SegID> >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Specify_SegID__exposer.def( "__str__", &__str__< ::SireID::Specify<SireMol::SegID> > ); Specify_SegID__exposer.def( "__repr__", &__str__< ::SireID::Specify<SireMol::SegID> > ); } }
void register_Conditional_class(){ { //::SireCAS::Conditional typedef bp::class_< SireCAS::Conditional, bp::bases< SireCAS::ExBase > > Conditional_exposer_t; Conditional_exposer_t Conditional_exposer = Conditional_exposer_t( "Conditional", "This is a conditional expression. If the condition is true,\nthen true_expression is evaluated, else if the condition\nis false then false_expression is evaluate\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") ); bp::scope Conditional_scope( Conditional_exposer ); Conditional_exposer.def( bp::init< SireCAS::Condition const &, SireCAS::Expression const &, SireCAS::Expression const & >(( bp::arg("condition"), bp::arg("true_expression"), bp::arg("false_expression") ), "Construct a conditional where if condition is true, then\ntrue_expression is evaluated, while if condition is false,\nthen false_expression is evaluated") ); Conditional_exposer.def( bp::init< SireCAS::Conditional const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireCAS::Conditional::children typedef ::SireCAS::Expressions ( ::SireCAS::Conditional::*children_function_type)( ) const; children_function_type children_function_value( &::SireCAS::Conditional::children ); Conditional_exposer.def( "children" , children_function_value , "Return the children of this expression" ); } { //::SireCAS::Conditional::condition typedef ::SireCAS::Condition const & ( ::SireCAS::Conditional::*condition_function_type)( ) const; condition_function_type condition_function_value( &::SireCAS::Conditional::condition ); Conditional_exposer.def( "condition" , condition_function_value , bp::return_value_policy<bp::clone_const_reference>() , "Return the condition" ); } { //::SireCAS::Conditional::conjugate typedef ::SireCAS::Expression ( ::SireCAS::Conditional::*conjugate_function_type)( ) const; conjugate_function_type conjugate_function_value( &::SireCAS::Conditional::conjugate ); Conditional_exposer.def( "conjugate" , conjugate_function_value , "Return the complex conjugate of this expression" ); } { //::SireCAS::Conditional::differentiate typedef ::SireCAS::Expression ( ::SireCAS::Conditional::*differentiate_function_type)( ::SireCAS::Symbol const & ) const; differentiate_function_type differentiate_function_value( &::SireCAS::Conditional::differentiate ); Conditional_exposer.def( "differentiate" , differentiate_function_value , ( bp::arg("symbol") ) , "Return the differential of this expression" ); } { //::SireCAS::Conditional::evaluate typedef double ( ::SireCAS::Conditional::*evaluate_function_type)( ::SireCAS::Values const & ) const; evaluate_function_type evaluate_function_value( &::SireCAS::Conditional::evaluate ); Conditional_exposer.def( "evaluate" , evaluate_function_value , ( bp::arg("values") ) , "Evaluate this expression for the passed values" ); } { //::SireCAS::Conditional::evaluate typedef ::SireMaths::Complex ( ::SireCAS::Conditional::*evaluate_function_type)( ::SireCAS::ComplexValues const & ) const; evaluate_function_type evaluate_function_value( &::SireCAS::Conditional::evaluate ); Conditional_exposer.def( "evaluate" , evaluate_function_value , ( bp::arg("values") ) , "Evaluate this expresion for the passed values" ); } { //::SireCAS::Conditional::expand typedef ::QList< SireCAS::Factor > ( ::SireCAS::Conditional::*expand_function_type)( ::SireCAS::Symbol const & ) const; expand_function_type expand_function_value( &::SireCAS::Conditional::expand ); Conditional_exposer.def( "expand" , expand_function_value , ( bp::arg("symbol") ) , "Expand this expression in terms of symbol" ); } { //::SireCAS::Conditional::falseExpression typedef ::SireCAS::Expression const & ( ::SireCAS::Conditional::*falseExpression_function_type)( ) const; falseExpression_function_type falseExpression_function_value( &::SireCAS::Conditional::falseExpression ); Conditional_exposer.def( "falseExpression" , falseExpression_function_value , bp::return_value_policy< bp::copy_const_reference >() , "Return the expression to be evaluated if the condition is false" ); } { //::SireCAS::Conditional::functions typedef ::SireCAS::Functions ( ::SireCAS::Conditional::*functions_function_type)( ) const; functions_function_type functions_function_value( &::SireCAS::Conditional::functions ); Conditional_exposer.def( "functions" , functions_function_value , "Return the functions used in this expression" ); } { //::SireCAS::Conditional::hash typedef ::uint ( ::SireCAS::Conditional::*hash_function_type)( ) const; hash_function_type hash_function_value( &::SireCAS::Conditional::hash ); Conditional_exposer.def( "hash" , hash_function_value , "Hash this conditional" ); } { //::SireCAS::Conditional::integrate typedef ::SireCAS::Expression ( ::SireCAS::Conditional::*integrate_function_type)( ::SireCAS::Symbol const & ) const; integrate_function_type integrate_function_value( &::SireCAS::Conditional::integrate ); Conditional_exposer.def( "integrate" , integrate_function_value , ( bp::arg("symbol") ) , "Return the integral of this expression" ); } { //::SireCAS::Conditional::isComplex typedef bool ( ::SireCAS::Conditional::*isComplex_function_type)( ) const; isComplex_function_type isComplex_function_value( &::SireCAS::Conditional::isComplex ); Conditional_exposer.def( "isComplex" , isComplex_function_value , "Is this a complex expression?" ); } { //::SireCAS::Conditional::isCompound typedef bool ( ::SireCAS::Conditional::*isCompound_function_type)( ) const; isCompound_function_type isCompound_function_value( &::SireCAS::Conditional::isCompound ); Conditional_exposer.def( "isCompound" , isCompound_function_value , "Is this a compound expression?" ); } { //::SireCAS::Conditional::isConstant typedef bool ( ::SireCAS::Conditional::*isConstant_function_type)( ) const; isConstant_function_type isConstant_function_value( &::SireCAS::Conditional::isConstant ); Conditional_exposer.def( "isConstant" , isConstant_function_value , "Return whether or not this is constant" ); } { //::SireCAS::Conditional::isFunction typedef bool ( ::SireCAS::Conditional::*isFunction_function_type)( ::SireCAS::Symbol const & ) const; isFunction_function_type isFunction_function_value( &::SireCAS::Conditional::isFunction ); Conditional_exposer.def( "isFunction" , isFunction_function_value , ( bp::arg("arg0") ) , "Return whether or not this is a function of symbol" ); } { //::SireCAS::Conditional::isNull typedef bool ( ::SireCAS::Conditional::*isNull_function_type)( ) const; isNull_function_type isNull_function_value( &::SireCAS::Conditional::isNull ); Conditional_exposer.def( "isNull" , isNull_function_value , "Return whether or not this is null" ); } { //::SireCAS::Conditional::operator= typedef ::SireCAS::Conditional & ( ::SireCAS::Conditional::*assign_function_type)( ::SireCAS::Conditional const & ) ; assign_function_type assign_function_value( &::SireCAS::Conditional::operator= ); Conditional_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } Conditional_exposer.def( bp::self == bp::self ); Conditional_exposer.def( bp::self == bp::other< SireCAS::ExBase >() ); { //::SireCAS::Conditional::series typedef ::SireCAS::Expression ( ::SireCAS::Conditional::*series_function_type)( ::SireCAS::Symbol const &,int ) const; series_function_type series_function_value( &::SireCAS::Conditional::series ); Conditional_exposer.def( "series" , series_function_value , ( bp::arg("symbol"), bp::arg("n") ) , "Return the series expansion of this product with respect to symbol, to order n" ); } { //::SireCAS::Conditional::simplify typedef ::SireCAS::Expression ( ::SireCAS::Conditional::*simplify_function_type)( int ) const; simplify_function_type simplify_function_value( &::SireCAS::Conditional::simplify ); Conditional_exposer.def( "simplify" , simplify_function_value , ( bp::arg("options")=(int)(0) ) , "Try to simplify this condition" ); } { //::SireCAS::Conditional::substitute typedef ::SireCAS::Expression ( ::SireCAS::Conditional::*substitute_function_type)( ::SireCAS::Identities const & ) const; substitute_function_type substitute_function_value( &::SireCAS::Conditional::substitute ); Conditional_exposer.def( "substitute" , substitute_function_value , ( bp::arg("identities") ) , "Substitute identities into this expression" ); } { //::SireCAS::Conditional::symbols typedef ::SireCAS::Symbols ( ::SireCAS::Conditional::*symbols_function_type)( ) const; symbols_function_type symbols_function_value( &::SireCAS::Conditional::symbols ); Conditional_exposer.def( "symbols" , symbols_function_value , "Return the symbols used in this expression" ); } { //::SireCAS::Conditional::toString typedef ::QString ( ::SireCAS::Conditional::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireCAS::Conditional::toString ); Conditional_exposer.def( "toString" , toString_function_value , "Return a string representation of this conditional" ); } { //::SireCAS::Conditional::trueExpression typedef ::SireCAS::Expression const & ( ::SireCAS::Conditional::*trueExpression_function_type)( ) const; trueExpression_function_type trueExpression_function_value( &::SireCAS::Conditional::trueExpression ); Conditional_exposer.def( "trueExpression" , trueExpression_function_value , bp::return_value_policy< bp::copy_const_reference >() , "Return the expression to be evaluated if the condition is true" ); } { //::SireCAS::Conditional::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireCAS::Conditional::typeName ); Conditional_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireCAS::Conditional::what typedef char const * ( ::SireCAS::Conditional::*what_function_type)( ) const; what_function_type what_function_value( &::SireCAS::Conditional::what ); Conditional_exposer.def( "what" , what_function_value , "" ); } Conditional_exposer.staticmethod( "typeName" ); Conditional_exposer.def( "__copy__", &__copy__); Conditional_exposer.def( "__deepcopy__", &__copy__); Conditional_exposer.def( "clone", &__copy__); Conditional_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::Conditional >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Conditional_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::Conditional >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Conditional_exposer.def( "__str__", &__str__< ::SireCAS::Conditional > ); Conditional_exposer.def( "__repr__", &__str__< ::SireCAS::Conditional > ); Conditional_exposer.def( "__hash__", &::SireCAS::Conditional::hash ); } }
void register_ExBase_class(){ { //::SireCAS::ExBase typedef bp::class_< SireCAS::ExBase, boost::noncopyable > ExBase_exposer_t; ExBase_exposer_t ExBase_exposer = ExBase_exposer_t( "ExBase", "\nPure-virtual base class of all of the parts of mathematical expressions.\n\nThis class provides the atom of SireCAS. ExBase objects are combined together\nto form complete expressions. All constants, functions and symbols are derived\nfrom this object.\n\nThis class is an example of an implicitly shared, self-managed object, and\nis designed so that it can be held by SharedPolyPointer (indeed,\nExpressionBase is just a proxy for SharedPolyPointer<ExBase>).\n\nAuthor: Christopher Woods\n", bp::no_init ); bp::scope ExBase_scope( ExBase_exposer ); { //::SireCAS::ExBase::children typedef ::SireCAS::Expressions ( ::SireCAS::ExBase::*children_function_type)( ) const; children_function_type children_function_value( &::SireCAS::ExBase::children ); ExBase_exposer.def( "children" , children_function_value , "Return the child expressions of this Expression" ); } { //::SireCAS::ExBase::conjugate typedef ::SireCAS::Expression ( ::SireCAS::ExBase::*conjugate_function_type)( ) const; conjugate_function_type conjugate_function_value( &::SireCAS::ExBase::conjugate ); ExBase_exposer.def( "conjugate" , conjugate_function_value , "Return the complex conjugate of this expression" ); } { //::SireCAS::ExBase::differentiate typedef ::SireCAS::Expression ( ::SireCAS::ExBase::*differentiate_function_type)( ::SireCAS::Symbol const & ) const; differentiate_function_type differentiate_function_value( &::SireCAS::ExBase::differentiate ); ExBase_exposer.def( "differentiate" , differentiate_function_value , ( bp::arg("symbol") ) , "Return an expression that the differential of this ExBase\nwith respect to symbol. Note an exception may\nbe thrown if this ExBase cannot be differentiated.\nThrow: SireCAS::unavailable_differential\n" ); } { //::SireCAS::ExBase::evaluate typedef double ( ::SireCAS::ExBase::*evaluate_function_type)( ::SireCAS::Values const & ) const; evaluate_function_type evaluate_function_value( &::SireCAS::ExBase::evaluate ); ExBase_exposer.def( "evaluate" , evaluate_function_value , ( bp::arg("values") ) , "Evaluate this ExBase using values values. Any\nmissing symbols are assumed to equal zero.\n\nNote that an exception will be thrown if the result of the\nevaluation of this, or one of its children, is complex.\n\nThrow: SireMaths::domain_error\n" ); } { //::SireCAS::ExBase::evaluate typedef ::SireMaths::Complex ( ::SireCAS::ExBase::*evaluate_function_type)( ::SireCAS::ComplexValues const & ) const; evaluate_function_type evaluate_function_value( &::SireCAS::ExBase::evaluate ); ExBase_exposer.def( "evaluate" , evaluate_function_value , ( bp::arg("values") ) , "Evaluate this ExBase using the complex values values.\nAny missing symbols are assumed to equal zero." ); } { //::SireCAS::ExBase::expand typedef ::QList< SireCAS::Factor > ( ::SireCAS::ExBase::*expand_function_type)( ::SireCAS::Symbol const & ) const; expand_function_type expand_function_value( &::SireCAS::ExBase::expand ); ExBase_exposer.def( "expand" , expand_function_value , ( bp::arg("symbol") ) , "Rearrange this expression into the form\nm x^i + n x^j + ... + constant\nand return the factors and powers of x\n\nThrow: SireCAS::rearrangement_error\n" ); } { //::SireCAS::ExBase::functions typedef ::SireCAS::Functions ( ::SireCAS::ExBase::*functions_function_type)( ) const; functions_function_type functions_function_value( &::SireCAS::ExBase::functions ); ExBase_exposer.def( "functions" , functions_function_value , "Return the set of Functions that appear in this ExBase" ); } { //::SireCAS::ExBase::hash typedef ::uint ( ::SireCAS::ExBase::*hash_function_type)( ) const; hash_function_type hash_function_value( &::SireCAS::ExBase::hash ); ExBase_exposer.def( "hash" , hash_function_value , "Return a hash of this object - return a combination of the\nidentifying magic for the class and a hash for its contents." ); } { //::SireCAS::ExBase::integrate typedef ::SireCAS::Expression ( ::SireCAS::ExBase::*integrate_function_type)( ::SireCAS::Symbol const & ) const; integrate_function_type integrate_function_value( &::SireCAS::ExBase::integrate ); ExBase_exposer.def( "integrate" , integrate_function_value , ( bp::arg("symbol") ) , "Return the indefinite integral of this ExBase with respect to\nsymbol. This is not guaranteed to work() and will return an\nexpression of the form Sum( integral(exbase) + integral_constant ).\nIf it doesnt work then an exception will be throw.\nThrow: SireCAS::unavailable_integral\n" ); } { //::SireCAS::ExBase::isComplex typedef bool ( ::SireCAS::ExBase::*isComplex_function_type)( ) const; isComplex_function_type isComplex_function_value( &::SireCAS::ExBase::isComplex ); ExBase_exposer.def( "isComplex" , isComplex_function_value , "Return whether or not this expression contains any complex (imaginary)\nparts" ); } { //::SireCAS::ExBase::isCompound typedef bool ( ::SireCAS::ExBase::*isCompound_function_type)( ) const; isCompound_function_type isCompound_function_value( &::SireCAS::ExBase::isCompound ); ExBase_exposer.def( "isCompound" , isCompound_function_value , "Return whether or not this is a compound expression, and thus as such\nrequires brackets placed around it when it is printed. Examples include\nSum, Product and Power. For most other functions it is safe to leave\nthis as false." ); } { //::SireCAS::ExBase::isConstant typedef bool ( ::SireCAS::ExBase::*isConstant_function_type)( ) const; isConstant_function_type isConstant_function_value( &::SireCAS::ExBase::isConstant ); ExBase_exposer.def( "isConstant" , isConstant_function_value , "Return whether or not this is a constant expression (does not\ndepend on any symbols)" ); } { //::SireCAS::ExBase::isFunction typedef bool ( ::SireCAS::ExBase::*isFunction_function_type)( ::SireCAS::Symbol const & ) const; isFunction_function_type isFunction_function_value( &::SireCAS::ExBase::isFunction ); ExBase_exposer.def( "isFunction" , isFunction_function_value , ( bp::arg("arg0") ) , "Return whether or not this is a function of the passed Symbol" ); } ExBase_exposer.def( bp::self != bp::self ); ExBase_exposer.def( -bp::self ); { //::SireCAS::ExBase::operator= typedef ::SireCAS::ExBase & ( ::SireCAS::ExBase::*assign_function_type)( ::SireCAS::ExBase const & ) ; assign_function_type assign_function_value( &::SireCAS::ExBase::operator= ); ExBase_exposer.def( "assign" , assign_function_value , ( bp::arg("arg0") ) , bp::return_self< >() , "Assignment operator" ); } ExBase_exposer.def( bp::self == bp::self ); { //::SireCAS::ExBase::series typedef ::SireCAS::Expression ( ::SireCAS::ExBase::*series_function_type)( ::SireCAS::Symbol const &,int ) const; series_function_type series_function_value( &::SireCAS::ExBase::series ); ExBase_exposer.def( "series" , series_function_value , ( bp::arg("symbol"), bp::arg("n") ) , "Return a series expansion of this expression with respect to\nsymbol, if possible, to order\nn. This is not guaranteed to work, and will return this expression\nunchanged if it doesnt work. If it is expanded, then a series\nwill be returned, together with an estimate of the error (e.g. O(x^2))" ); } { //::SireCAS::ExBase::simplify typedef ::SireCAS::Expression ( ::SireCAS::ExBase::*simplify_function_type)( int ) const; simplify_function_type simplify_function_value( &::SireCAS::ExBase::simplify ); ExBase_exposer.def( "simplify" , simplify_function_value , ( bp::arg("options")=(int)(0) ) , "Try to simplify this expression. This will try to use known mathematical\nidentities to convert complex expressions down to more simple ones.\nIf SireCAS::UNSAFE_COMPLEX_SIMPLIFICATIONS is true, then identities\nthat are not safe for complex math are used, e.g. z = sin(arcsin(z))." ); } { //::SireCAS::ExBase::substitute typedef ::SireCAS::Expression ( ::SireCAS::ExBase::*substitute_function_type)( ::SireCAS::Identities const & ) const; substitute_function_type substitute_function_value( &::SireCAS::ExBase::substitute ); ExBase_exposer.def( "substitute" , substitute_function_value , ( bp::arg("identities") ) , "Return an expression that has the identities in identities\nsubstituted into this expression" ); } { //::SireCAS::ExBase::symbols typedef ::SireCAS::Symbols ( ::SireCAS::ExBase::*symbols_function_type)( ) const; symbols_function_type symbols_function_value( &::SireCAS::ExBase::symbols ); ExBase_exposer.def( "symbols" , symbols_function_value , "Return the set of Symbols that appear in this ExBase" ); } { //::SireCAS::ExBase::toOpenMMString typedef ::QString ( ::SireCAS::ExBase::*toOpenMMString_function_type)( ) const; toOpenMMString_function_type toOpenMMString_function_value( &::SireCAS::ExBase::toOpenMMString ); ExBase_exposer.def( "toOpenMMString" , toOpenMMString_function_value , "Return a string representation of this object in the OpenMM syntax" ); } { //::SireCAS::ExBase::toString typedef ::QString ( ::SireCAS::ExBase::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireCAS::ExBase::toString ); ExBase_exposer.def( "toString" , toString_function_value , "Return a string representation of this object" ); } { //::SireCAS::ExBase::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireCAS::ExBase::typeName ); ExBase_exposer.def( "typeName" , typeName_function_value , "Return the name of this class type" ); } { //::SireCAS::ExBase::what typedef char const * ( ::SireCAS::ExBase::*what_function_type)( ) const; what_function_type what_function_value( &::SireCAS::ExBase::what ); ExBase_exposer.def( "what" , what_function_value , "Return the name of the type of this ExBase object" ); } ExBase_exposer.staticmethod( "typeName" ); ExBase_exposer.def( bp::self * bp::self ); ExBase_exposer.def( bp::self * bp::other< SireCAS::Expression >() ); ExBase_exposer.def( bp::self * bp::other< double >() ); ExBase_exposer.def( bp::other< double >() * bp::self ); ExBase_exposer.def( bp::self * bp::other< SireMaths::Complex >() ); ExBase_exposer.def( bp::self + bp::self ); ExBase_exposer.def( bp::self + bp::other< SireCAS::Expression >() ); ExBase_exposer.def( bp::self + bp::other< double >() ); ExBase_exposer.def( bp::other< double >() + bp::self ); ExBase_exposer.def( bp::self + bp::other< SireMaths::Complex >() ); ExBase_exposer.def( bp::self - bp::self ); ExBase_exposer.def( bp::self - bp::other< SireCAS::Expression >() ); ExBase_exposer.def( bp::self - bp::other< double >() ); ExBase_exposer.def( bp::other< double >() - bp::self ); ExBase_exposer.def( bp::self - bp::other< SireMaths::Complex >() ); ExBase_exposer.def( bp::self / bp::self ); ExBase_exposer.def( bp::self / bp::other< SireCAS::Expression >() ); ExBase_exposer.def( bp::self / bp::other< double >() ); ExBase_exposer.def( bp::other< double >() / bp::self ); ExBase_exposer.def( bp::self / bp::other< SireMaths::Complex >() ); ExBase_exposer.def( self + self ); ExBase_exposer.def( self - self ); ExBase_exposer.def( self * self ); ExBase_exposer.def( self / self ); ExBase_exposer.def( other<double>() + self ); ExBase_exposer.def( other<double>() - self ); ExBase_exposer.def( other<double>() * self ); ExBase_exposer.def( other<double>() / self ); ExBase_exposer.def( self + other<double>() ); ExBase_exposer.def( self - other<double>() ); ExBase_exposer.def( self * other<double>() ); ExBase_exposer.def( self / other<double>() ); ExBase_exposer.def( other<SireMaths::Complex>() + self ); ExBase_exposer.def( other<SireMaths::Complex>() - self ); ExBase_exposer.def( other<SireMaths::Complex>() * self ); ExBase_exposer.def( other<SireMaths::Complex>() / self ); ExBase_exposer.def( self + other<SireMaths::Complex>() ); ExBase_exposer.def( self - other<SireMaths::Complex>() ); ExBase_exposer.def( self * other<SireMaths::Complex>() ); ExBase_exposer.def( self / other<SireMaths::Complex>() ); ExBase_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::ExBase >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); ExBase_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::ExBase >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); ExBase_exposer.def( "__str__", &__str__< ::SireCAS::ExBase > ); ExBase_exposer.def( "__repr__", &__str__< ::SireCAS::ExBase > ); ExBase_exposer.def( "__hash__", &::SireCAS::ExBase::hash ); } }
void register_Symbol_class(){ { //::SireCAS::Symbol typedef bp::class_< SireCAS::Symbol, bp::bases< SireCAS::ExBase > > Symbol_exposer_t; Symbol_exposer_t Symbol_exposer = Symbol_exposer_t( "Symbol", bp::init< >() ); bp::scope Symbol_scope( Symbol_exposer ); Symbol_exposer.def( bp::init< SireCAS::SymbolID >(( bp::arg("symid") )) ); Symbol_exposer.def( bp::init< QString const & >(( bp::arg("rep") )) ); Symbol_exposer.def( bp::init< SireCAS::Symbol const & >(( bp::arg("other") )) ); { //::SireCAS::Symbol::ID typedef ::SireCAS::SymbolID ( ::SireCAS::Symbol::*ID_function_type )( ) const; ID_function_type ID_function_value( &::SireCAS::Symbol::ID ); Symbol_exposer.def( "ID" , ID_function_value ); } { //::SireCAS::Symbol::children typedef ::SireCAS::Expressions ( ::SireCAS::Symbol::*children_function_type )( ) const; children_function_type children_function_value( &::SireCAS::Symbol::children ); Symbol_exposer.def( "children" , children_function_value ); } { //::SireCAS::Symbol::differentiate typedef ::SireCAS::Expression ( ::SireCAS::Symbol::*differentiate_function_type )( ::SireCAS::Symbol const & ) const; differentiate_function_type differentiate_function_value( &::SireCAS::Symbol::differentiate ); Symbol_exposer.def( "differentiate" , differentiate_function_value , ( bp::arg("symbol") ) ); } { //::SireCAS::Symbol::evaluate typedef double ( ::SireCAS::Symbol::*evaluate_function_type )( ::SireCAS::Values const & ) const; evaluate_function_type evaluate_function_value( &::SireCAS::Symbol::evaluate ); Symbol_exposer.def( "evaluate" , evaluate_function_value , ( bp::arg("values") ) ); } { //::SireCAS::Symbol::evaluate typedef ::SireMaths::Complex ( ::SireCAS::Symbol::*evaluate_function_type )( ::SireCAS::ComplexValues const & ) const; evaluate_function_type evaluate_function_value( &::SireCAS::Symbol::evaluate ); Symbol_exposer.def( "evaluate" , evaluate_function_value , ( bp::arg("values") ) ); } { //::SireCAS::Symbol::expand typedef ::QList< SireCAS::Factor > ( ::SireCAS::Symbol::*expand_function_type )( ::SireCAS::Symbol const & ) const; expand_function_type expand_function_value( &::SireCAS::Symbol::expand ); Symbol_exposer.def( "expand" , expand_function_value , ( bp::arg("symbol") ) ); } { //::SireCAS::Symbol::functions typedef ::SireCAS::Functions ( ::SireCAS::Symbol::*functions_function_type )( ) const; functions_function_type functions_function_value( &::SireCAS::Symbol::functions ); Symbol_exposer.def( "functions" , functions_function_value ); } { //::SireCAS::Symbol::hash typedef ::uint ( ::SireCAS::Symbol::*hash_function_type )( ) const; hash_function_type hash_function_value( &::SireCAS::Symbol::hash ); Symbol_exposer.def( "hash" , hash_function_value ); } { //::SireCAS::Symbol::integrate typedef ::SireCAS::Expression ( ::SireCAS::Symbol::*integrate_function_type )( ::SireCAS::Symbol const & ) const; integrate_function_type integrate_function_value( &::SireCAS::Symbol::integrate ); Symbol_exposer.def( "integrate" , integrate_function_value , ( bp::arg("symbol") ) ); } { //::SireCAS::Symbol::isConstant typedef bool ( ::SireCAS::Symbol::*isConstant_function_type )( ) const; isConstant_function_type isConstant_function_value( &::SireCAS::Symbol::isConstant ); Symbol_exposer.def( "isConstant" , isConstant_function_value ); } { //::SireCAS::Symbol::isFunction typedef bool ( ::SireCAS::Symbol::*isFunction_function_type )( ::SireCAS::Symbol const & ) const; isFunction_function_type isFunction_function_value( &::SireCAS::Symbol::isFunction ); Symbol_exposer.def( "isFunction" , isFunction_function_value , ( bp::arg("arg0") ) ); } { //::SireCAS::Symbol::isNull typedef bool ( ::SireCAS::Symbol::*isNull_function_type )( ) const; isNull_function_type isNull_function_value( &::SireCAS::Symbol::isNull ); Symbol_exposer.def( "isNull" , isNull_function_value ); } Symbol_exposer.def( bp::self < bp::self ); Symbol_exposer.def( bp::self <= bp::self ); { //::SireCAS::Symbol::operator= typedef ::SireCAS::Symbol & ( ::SireCAS::Symbol::*assign_function_type )( ::SireCAS::Symbol const & ) ; assign_function_type assign_function_value( &::SireCAS::Symbol::operator= ); Symbol_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } { //::SireCAS::Symbol::operator= typedef ::SireCAS::Symbol & ( ::SireCAS::Symbol::*assign_function_type )( ::SireCAS::SymbolID ) ; assign_function_type assign_function_value( &::SireCAS::Symbol::operator= ); Symbol_exposer.def( "assign" , assign_function_value , ( bp::arg("symid") ) , bp::return_self< >() ); } Symbol_exposer.def( bp::self == bp::other< double >() ); Symbol_exposer.def( bp::self == bp::other< int >() ); Symbol_exposer.def( bp::self == bp::other< SireMaths::Complex >() ); Symbol_exposer.def( bp::self == bp::other< SireCAS::Expression >() ); Symbol_exposer.def( bp::self == bp::other< SireCAS::ExBase >() ); Symbol_exposer.def( bp::self > bp::self ); Symbol_exposer.def( bp::self >= bp::self ); { //::SireCAS::Symbol::substitute typedef ::SireCAS::Expression ( ::SireCAS::Symbol::*substitute_function_type )( ::SireCAS::Identities const & ) const; substitute_function_type substitute_function_value( &::SireCAS::Symbol::substitute ); Symbol_exposer.def( "substitute" , substitute_function_value , ( bp::arg("identities") ) ); } { //::SireCAS::Symbol::symbols typedef ::SireCAS::Symbols ( ::SireCAS::Symbol::*symbols_function_type )( ) const; symbols_function_type symbols_function_value( &::SireCAS::Symbol::symbols ); Symbol_exposer.def( "symbols" , symbols_function_value ); } { //::SireCAS::Symbol::toString typedef ::QString ( ::SireCAS::Symbol::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireCAS::Symbol::toString ); Symbol_exposer.def( "toString" , toString_function_value ); } { //::SireCAS::Symbol::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireCAS::Symbol::typeName ); Symbol_exposer.def( "typeName" , typeName_function_value ); } { //::SireCAS::Symbol::what typedef char const * ( ::SireCAS::Symbol::*what_function_type )( ) const; what_function_type what_function_value( &::SireCAS::Symbol::what ); Symbol_exposer.def( "what" , what_function_value ); } Symbol_exposer.staticmethod( "typeName" ); Symbol_exposer.def( "__copy__", &__copy__); Symbol_exposer.def( "__deepcopy__", &__copy__); Symbol_exposer.def( "clone", &__copy__); Symbol_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::Symbol >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Symbol_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::Symbol >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Symbol_exposer.def( "__str__", &__str__< ::SireCAS::Symbol > ); Symbol_exposer.def( "__repr__", &__str__< ::SireCAS::Symbol > ); } }