C++ what_function_value函数代码示例

//.........这里部分代码省略.........
        
        }
        { //::SireMM::CLJAtom::isDummy
        
            typedef bool ( ::SireMM::CLJAtom::*isDummy_function_type )(  ) const;
            isDummy_function_type isDummy_function_value( &::SireMM::CLJAtom::isDummy );
            
            CLJAtom_exposer.def( 
                "isDummy"
                , isDummy_function_value );
        
        }
        { //::SireMM::CLJAtom::isNull
        
            typedef bool ( ::SireMM::CLJAtom::*isNull_function_type )(  ) const;
            isNull_function_type isNull_function_value( &::SireMM::CLJAtom::isNull );
            
            CLJAtom_exposer.def( 
                "isNull"
                , isNull_function_value );
        
        }
        { //::SireMM::CLJAtom::ljParameter
        
            typedef ::SireMM::LJParameter ( ::SireMM::CLJAtom::*ljParameter_function_type )(  ) const;
            ljParameter_function_type ljParameter_function_value( &::SireMM::CLJAtom::ljParameter );
            
            CLJAtom_exposer.def( 
                "ljParameter"
                , ljParameter_function_value );
        
        }
        { //::SireMM::CLJAtom::negate
        
            typedef ::SireMM::CLJAtom ( ::SireMM::CLJAtom::*negate_function_type )(  ) const;
            negate_function_type negate_function_value( &::SireMM::CLJAtom::negate );
            
            CLJAtom_exposer.def( 
                "negate"
                , negate_function_value );
        
        }
        CLJAtom_exposer.def( bp::self != bp::self );
        { //::SireMM::CLJAtom::operator=
        
            typedef ::SireMM::CLJAtom & ( ::SireMM::CLJAtom::*assign_function_type )( ::SireMM::CLJAtom const & ) ;
            assign_function_type assign_function_value( &::SireMM::CLJAtom::operator= );
            
            CLJAtom_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        CLJAtom_exposer.def( bp::self == bp::self );
        { //::SireMM::CLJAtom::toString
        
            typedef ::QString ( ::SireMM::CLJAtom::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireMM::CLJAtom::toString );
            
            CLJAtom_exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireMM::CLJAtom::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMM::CLJAtom::typeName );
            
            CLJAtom_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireMM::CLJAtom::what
        
            typedef char const * ( ::SireMM::CLJAtom::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireMM::CLJAtom::what );
            
            CLJAtom_exposer.def( 
                "what"
                , what_function_value );
        
        }
        CLJAtom_exposer.staticmethod( "buildFrom" );
        CLJAtom_exposer.staticmethod( "typeName" );
        CLJAtom_exposer.def( "__copy__", &__copy__);
        CLJAtom_exposer.def( "__deepcopy__", &__copy__);
        CLJAtom_exposer.def( "clone", &__copy__);
        CLJAtom_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::CLJAtom >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        CLJAtom_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::CLJAtom >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        CLJAtom_exposer.def( "__str__", &__str__< ::SireMM::CLJAtom > );
        CLJAtom_exposer.def( "__repr__", &__str__< ::SireMM::CLJAtom > );
    }

}

//.........这里部分代码省略.........
                , ( bp::arg("i"), bp::arg("t") )
                , "Transform all of the coordinates in the CoordGroup at index i using\nthe transformation t\nThrow: SireError::invalid_index\n" );
        
        }
        { //::SireVol::CoordGroupArray::translate
        
            typedef void ( ::SireVol::CoordGroupArray::*translate_function_type)( ::SireMaths::Vector const & ) ;
            translate_function_type translate_function_value( &::SireVol::CoordGroupArray::translate );
            
            CoordGroupArray_exposer.def( 
                "translate"
                , translate_function_value
                , ( bp::arg("delta") )
                , "Translate all of the coordinates in this array by delta" );
        
        }
        { //::SireVol::CoordGroupArray::translate
        
            typedef void ( ::SireVol::CoordGroupArray::*translate_function_type)( ::quint32,::SireMaths::Vector const & ) ;
            translate_function_type translate_function_value( &::SireVol::CoordGroupArray::translate );
            
            CoordGroupArray_exposer.def( 
                "translate"
                , translate_function_value
                , ( bp::arg("i"), bp::arg("delta") )
                , "Translate all of the coordinates in the ith CoordGroup by delta" );
        
        }
        { //::SireVol::CoordGroupArray::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireVol::CoordGroupArray::typeName );
            
            CoordGroupArray_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        { //::SireVol::CoordGroupArray::update
        
            typedef void ( ::SireVol::CoordGroupArray::*update_function_type)( ::quint32,::SireVol::CoordGroup const & ) ;
            update_function_type update_function_value( &::SireVol::CoordGroupArray::update );
            
            CoordGroupArray_exposer.def( 
                "update"
                , update_function_value
                , ( bp::arg("i"), bp::arg("cgroup") )
                , "Update the CoordGroup at index i so that it is equal to cgroup. Note\nthat cgroup must contain the same number of coordinates as the existing\nCoordGroup at this index\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" );
        
        }
        { //::SireVol::CoordGroupArray::update
        
            typedef void ( ::SireVol::CoordGroupArray::*update_function_type)( ::quint32,::QVector< SireMaths::Vector > const & ) ;
            update_function_type update_function_value( &::SireVol::CoordGroupArray::update );
            
            CoordGroupArray_exposer.def( 
                "update"
                , update_function_value
                , ( bp::arg("i"), bp::arg("coords") )
                , "Update the CoordGroup at index i so that it has coordinates coords\nThere must contain the same number of coordinates as the existing\nCoordGroup at this index\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" );
        
        }
        { //::SireVol::CoordGroupArray::update
        
            typedef void ( ::SireVol::CoordGroupArray::*update_function_type)( ::quint32,::SireMaths::Vector const *,int ) ;
            update_function_type update_function_value( &::SireVol::CoordGroupArray::update );
            
            CoordGroupArray_exposer.def( 
                "update"
                , update_function_value
                , ( bp::arg("i"), bp::arg("coords"), bp::arg("ncoords") )
                , "Update the CoordGroup at index i so that it has coordinates coords\n(there are ncoords coordinates in this array)\nThere must contain the same number of coordinates as the existing\nCoordGroup at this index\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" );
        
        }
        { //::SireVol::CoordGroupArray::what
        
            typedef char const * ( ::SireVol::CoordGroupArray::*what_function_type)(  ) const;
            what_function_type what_function_value( &::SireVol::CoordGroupArray::what );
            
            CoordGroupArray_exposer.def( 
                "what"
                , what_function_value
                , "" );
        
        }
        CoordGroupArray_exposer.staticmethod( "typeName" );
        CoordGroupArray_exposer.def( "__copy__", &__copy__);
        CoordGroupArray_exposer.def( "__deepcopy__", &__copy__);
        CoordGroupArray_exposer.def( "clone", &__copy__);
        CoordGroupArray_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::CoordGroupArray >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        CoordGroupArray_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::CoordGroupArray >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        CoordGroupArray_exposer.def( "__str__", &__str__< ::SireVol::CoordGroupArray > );
        CoordGroupArray_exposer.def( "__repr__", &__str__< ::SireVol::CoordGroupArray > );
        CoordGroupArray_exposer.def( "__len__", &__len_size< ::SireVol::CoordGroupArray > );
    }

}

//.........这里部分代码省略.........
                "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 );
    }

}

//.........这里部分代码省略.........
        }
        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> > );
    }

}

//.........这里部分代码省略.........
            
            MultiVector_exposer.def( 
                "swap"
                , swap_function_value
                , ( bp::arg("v0"), bp::arg("idx0"), bp::arg("v1"), bp::arg("idx1") )
                , "Swap the values of the value at index idx0 in f0 with the value at index idx in f1" );
        
        }
        { //::SireMaths::MultiVector::toString
        
            typedef ::QString ( ::SireMaths::MultiVector::*toString_function_type)(  ) const;
            toString_function_type toString_function_value( &::SireMaths::MultiVector::toString );
            
            MultiVector_exposer.def( 
                "toString"
                , toString_function_value
                , "Return a QString representation of the vector" );
        
        }
        { //::SireMaths::MultiVector::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMaths::MultiVector::typeName );
            
            MultiVector_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        { //::SireMaths::MultiVector::what
        
            typedef char const * ( ::SireMaths::MultiVector::*what_function_type)(  ) const;
            what_function_type what_function_value( &::SireMaths::MultiVector::what );
            
            MultiVector_exposer.def( 
                "what"
                , what_function_value
                , "" );
        
        }
        { //::SireMaths::MultiVector::x
        
            typedef ::SireMaths::MultiDouble const & ( ::SireMaths::MultiVector::*x_function_type)(  ) const;
            x_function_type x_function_value( &::SireMaths::MultiVector::x );
            
            MultiVector_exposer.def( 
                "x"
                , x_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireMaths::MultiVector::y
        
            typedef ::SireMaths::MultiDouble const & ( ::SireMaths::MultiVector::*y_function_type)(  ) const;
            y_function_type y_function_value( &::SireMaths::MultiVector::y );
            
            MultiVector_exposer.def( 
                "y"
                , y_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireMaths::MultiVector::z

void register_AngleComponent_class(){

    { //::SireMM::AngleComponent
        typedef bp::class_< SireMM::AngleComponent, bp::bases< SireFF::FFComponent, SireCAS::Symbol, SireCAS::ExBase > > AngleComponent_exposer_t;
        AngleComponent_exposer_t AngleComponent_exposer = AngleComponent_exposer_t( "AngleComponent", "This class represents a Angle component of a forcefield", bp::init< bp::optional< SireFF::FFName const & > >(( bp::arg("ffname")=SireFF::FFName() ), "Constructor") );
        bp::scope AngleComponent_scope( AngleComponent_exposer );
        AngleComponent_exposer.def( bp::init< SireCAS::Symbol const & >(( bp::arg("symbol") ), "Construct from a symbol\nThrow: SireError::incompatible_error\n") );
        AngleComponent_exposer.def( bp::init< SireMM::AngleComponent const & >(( bp::arg("other") ), "Copy constructor") );
        { //::SireMM::AngleComponent::changeEnergy
        
            typedef void ( ::SireMM::AngleComponent::*changeEnergy_function_type)( ::SireFF::FF &,::SireMM::AngleEnergy const & ) const;
            changeEnergy_function_type changeEnergy_function_value( &::SireMM::AngleComponent::changeEnergy );
            
            AngleComponent_exposer.def( 
                "changeEnergy"
                , changeEnergy_function_value
                , ( bp::arg("ff"), bp::arg("angnrg") )
                , "Change the component of the energy in the forcefield ff\nby delta" );
        
        }
        { //::SireMM::AngleComponent::setEnergy
        
            typedef void ( ::SireMM::AngleComponent::*setEnergy_function_type)( ::SireFF::FF &,::SireMM::AngleEnergy const & ) const;
            setEnergy_function_type setEnergy_function_value( &::SireMM::AngleComponent::setEnergy );
            
            AngleComponent_exposer.def( 
                "setEnergy"
                , setEnergy_function_value
                , ( bp::arg("ff"), bp::arg("angnrg") )
                , "Set the component of the energy in the forcefield ff\nto be equal to the passed energy" );
        
        }
        { //::SireMM::AngleComponent::symbols
        
            typedef ::SireCAS::Symbols ( ::SireMM::AngleComponent::*symbols_function_type)(  ) const;
            symbols_function_type symbols_function_value( &::SireMM::AngleComponent::symbols );
            
            AngleComponent_exposer.def( 
                "symbols"
                , symbols_function_value
                , "" );
        
        }
        { //::SireMM::AngleComponent::total
        
            typedef ::SireMM::AngleComponent const & ( ::SireMM::AngleComponent::*total_function_type)(  ) const;
            total_function_type total_function_value( &::SireMM::AngleComponent::total );
            
            AngleComponent_exposer.def( 
                "total"
                , total_function_value
                , bp::return_value_policy<bp::clone_const_reference>()
                , "" );
        
        }
        { //::SireMM::AngleComponent::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMM::AngleComponent::typeName );
            
            AngleComponent_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        { //::SireMM::AngleComponent::what
        
            typedef char const * ( ::SireMM::AngleComponent::*what_function_type)(  ) const;
            what_function_type what_function_value( &::SireMM::AngleComponent::what );
            
            AngleComponent_exposer.def( 
                "what"
                , what_function_value
                , "" );
        
        }
        AngleComponent_exposer.staticmethod( "typeName" );
        AngleComponent_exposer.def( "__copy__", &__copy__);
        AngleComponent_exposer.def( "__deepcopy__", &__copy__);
        AngleComponent_exposer.def( "clone", &__copy__);
        AngleComponent_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::AngleComponent >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        AngleComponent_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::AngleComponent >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        AngleComponent_exposer.def( "__str__", &__str__< ::SireMM::AngleComponent > );
        AngleComponent_exposer.def( "__repr__", &__str__< ::SireMM::AngleComponent > );
        AngleComponent_exposer.def( "__hash__", &::SireMM::AngleComponent::hash );
    }

}

//.........这里部分代码省略.........
        { //::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 );

//.........这里部分代码省略.........
            run_function_type run_function_value( &::SireBase::Process::run );
            
            Process_exposer.def( 
                "run"
                , run_function_value
                , ( bp::arg("command") )
                , "Run the command command and return a Process object that can be\nused to monitor the command" );
        
        }
        { //::SireBase::Process::run
        
            typedef ::SireBase::Process ( *run_function_type )( ::QString const &,::QString const & );
            run_function_type run_function_value( &::SireBase::Process::run );
            
            Process_exposer.def( 
                "run"
                , run_function_value
                , ( bp::arg("command"), bp::arg("arg") )
                , "Run the command command with the solitary argument arg" );
        
        }
        { //::SireBase::Process::run
        
            typedef ::SireBase::Process ( *run_function_type )( ::QString const &,::QStringList const & );
            run_function_type run_function_value( &::SireBase::Process::run );
            
            Process_exposer.def( 
                "run"
                , run_function_value
                , ( bp::arg("command"), bp::arg("arguments") )
                , "Run the command command with the arguments arguments, and\nreturn a Process object that can be used to query and control the\njob" );
        
        }
        { //::SireBase::Process::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireBase::Process::typeName );
            
            Process_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        { //::SireBase::Process::wait
        
            typedef void ( ::SireBase::Process::*wait_function_type)(  ) ;
            wait_function_type wait_function_value( &::SireBase::Process::wait );
            
            Process_exposer.def( 
                "wait"
                , wait_function_value
                , "Wait until the process has finished" );
        
        }
        { //::SireBase::Process::wait
        
            typedef bool ( ::SireBase::Process::*wait_function_type)( int ) ;
            wait_function_type wait_function_value( &::SireBase::Process::wait );
            
            Process_exposer.def( 
                "wait"
                , wait_function_value
                , ( bp::arg("ms") )
                , "Wait until the process has finished, or until ms milliseconds have passed.\nThis returns whether or not the process has finished" );
        
        }
        { //::SireBase::Process::wasKilled
        
            typedef bool ( ::SireBase::Process::*wasKilled_function_type)(  ) ;
            wasKilled_function_type wasKilled_function_value( &::SireBase::Process::wasKilled );
            
            Process_exposer.def( 
                "wasKilled"
                , wasKilled_function_value
                , "Return whether or not the process was killed" );
        
        }
        { //::SireBase::Process::what
        
            typedef char const * ( ::SireBase::Process::*what_function_type)(  ) const;
            what_function_type what_function_value( &::SireBase::Process::what );
            
            Process_exposer.def( 
                "what"
                , what_function_value
                , "" );
        
        }
        Process_exposer.staticmethod( "killAll" );
        Process_exposer.staticmethod( "run" );
        Process_exposer.staticmethod( "typeName" );
        Process_exposer.def( "__copy__", &__copy__);
        Process_exposer.def( "__deepcopy__", &__copy__);
        Process_exposer.def( "clone", &__copy__);
        Process_exposer.def( "__str__", &pvt_get_name);
        Process_exposer.def( "__repr__", &pvt_get_name);
    }

}

//.........这里部分代码省略.........
            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 > );
    }

}

//.........这里部分代码省略.........
        
            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> > );
    }

}

//.........这里部分代码省略.........
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        Process_exposer.def( bp::self == bp::self );
        { //::SireBase::Process::run
        
            typedef ::SireBase::Process ( *run_function_type )( ::QString const & );
            run_function_type run_function_value( &::SireBase::Process::run );
            
            Process_exposer.def( 
                "run"
                , run_function_value
                , ( bp::arg("command") ) );
        
        }
        { //::SireBase::Process::run
        
            typedef ::SireBase::Process ( *run_function_type )( ::QString const &,::QString const & );
            run_function_type run_function_value( &::SireBase::Process::run );
            
            Process_exposer.def( 
                "run"
                , run_function_value
                , ( bp::arg("command"), bp::arg("arg") ) );
        
        }
        { //::SireBase::Process::run
        
            typedef ::SireBase::Process ( *run_function_type )( ::QString const &,::QStringList const & );
            run_function_type run_function_value( &::SireBase::Process::run );
            
            Process_exposer.def( 
                "run"
                , run_function_value
                , ( bp::arg("command"), bp::arg("arguments") ) );
        
        }
        { //::SireBase::Process::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireBase::Process::typeName );
            
            Process_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireBase::Process::wait
        
            typedef void ( ::SireBase::Process::*wait_function_type )(  ) ;
            wait_function_type wait_function_value( &::SireBase::Process::wait );
            
            Process_exposer.def( 
                "wait"
                , wait_function_value );
        
        }
        { //::SireBase::Process::wait
        
            typedef bool ( ::SireBase::Process::*wait_function_type )( int ) ;
            wait_function_type wait_function_value( &::SireBase::Process::wait );
            
            Process_exposer.def( 
                "wait"
                , wait_function_value
                , ( bp::arg("ms") ) );
        
        }
        { //::SireBase::Process::wasKilled
        
            typedef bool ( ::SireBase::Process::*wasKilled_function_type )(  ) ;
            wasKilled_function_type wasKilled_function_value( &::SireBase::Process::wasKilled );
            
            Process_exposer.def( 
                "wasKilled"
                , wasKilled_function_value );
        
        }
        { //::SireBase::Process::what
        
            typedef char const * ( ::SireBase::Process::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireBase::Process::what );
            
            Process_exposer.def( 
                "what"
                , what_function_value );
        
        }
        Process_exposer.staticmethod( "killAll" );
        Process_exposer.staticmethod( "run" );
        Process_exposer.staticmethod( "typeName" );
        Process_exposer.def( "__copy__", &__copy__);
        Process_exposer.def( "__deepcopy__", &__copy__);
        Process_exposer.def( "clone", &__copy__);
        Process_exposer.def( "__str__", &pvt_get_name);
        Process_exposer.def( "__repr__", &pvt_get_name);
    }

}

//.........这里部分代码省略.........
                , "Return the coordinates" );
        
        }
        { //::SireMM::InternalParameters3D::changedAllGroups
        
            typedef bool ( ::SireMM::InternalParameters3D::*changedAllGroups_function_type)( ::SireMM::InternalParameters3D const & ) const;
            changedAllGroups_function_type changedAllGroups_function_value( &::SireMM::InternalParameters3D::changedAllGroups );
            
            InternalParameters3D_exposer.def( 
                "changedAllGroups"
                , changedAllGroups_function_value
                , ( bp::arg("other") )
                , "Return whether or not all of the CutGroup have changed compared to other" );
        
        }
        { //::SireMM::InternalParameters3D::getChangedGroups
        
            typedef ::QSet< unsigned int > ( ::SireMM::InternalParameters3D::*getChangedGroups_function_type)( ::SireMM::InternalParameters3D const & ) const;
            getChangedGroups_function_type getChangedGroups_function_value( &::SireMM::InternalParameters3D::getChangedGroups );
            
            InternalParameters3D_exposer.def( 
                "getChangedGroups"
                , getChangedGroups_function_value
                , ( bp::arg("other") )
                , "Return the indicies of the CutGroups that have changed in other compared\nto this set of parameters" );
        
        }
        { //::SireMM::InternalParameters3D::nCutGroups
        
            typedef int ( ::SireMM::InternalParameters3D::*nCutGroups_function_type)(  ) const;
            nCutGroups_function_type nCutGroups_function_value( &::SireMM::InternalParameters3D::nCutGroups );
            
            InternalParameters3D_exposer.def( 
                "nCutGroups"
                , nCutGroups_function_value
                , "Return the number of CutGroups in the molecule whose parameters are\ncontained in this object" );
        
        }
        InternalParameters3D_exposer.def( bp::self != bp::self );
        { //::SireMM::InternalParameters3D::operator=
        
            typedef ::SireMM::InternalParameters3D & ( ::SireMM::InternalParameters3D::*assign_function_type)( ::SireMM::InternalParameters3D const & ) ;
            assign_function_type assign_function_value( &::SireMM::InternalParameters3D::operator= );
            
            InternalParameters3D_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >()
                , "" );
        
        }
        InternalParameters3D_exposer.def( bp::self == bp::self );
        { //::SireMM::InternalParameters3D::setAtomicCoordinates
        
            typedef void ( ::SireMM::InternalParameters3D::*setAtomicCoordinates_function_type)( ::SireFF::detail::AtomicCoords3D const & ) ;
            setAtomicCoordinates_function_type setAtomicCoordinates_function_value( &::SireMM::InternalParameters3D::setAtomicCoordinates );
            
            InternalParameters3D_exposer.def( 
                "setAtomicCoordinates"
                , setAtomicCoordinates_function_value
                , ( bp::arg("coords") )
                , "Set the coordinates used by these parameters" );
        
        }
        { //::SireMM::InternalParameters3D::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMM::InternalParameters3D::typeName );
            
            InternalParameters3D_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        { //::SireMM::InternalParameters3D::what
        
            typedef char const * ( ::SireMM::InternalParameters3D::*what_function_type)(  ) const;
            what_function_type what_function_value( &::SireMM::InternalParameters3D::what );
            
            InternalParameters3D_exposer.def( 
                "what"
                , what_function_value
                , "" );
        
        }
        InternalParameters3D_exposer.staticmethod( "typeName" );
        InternalParameters3D_exposer.def( "__copy__", &__copy__);
        InternalParameters3D_exposer.def( "__deepcopy__", &__copy__);
        InternalParameters3D_exposer.def( "clone", &__copy__);
        InternalParameters3D_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::InternalParameters3D >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        InternalParameters3D_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::InternalParameters3D >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        InternalParameters3D_exposer.def( "__str__", &pvt_get_name);
        InternalParameters3D_exposer.def( "__repr__", &pvt_get_name);
    }

}

void register_CLJSoftIntraShiftFunction_class(){

    { //::SireMM::CLJSoftIntraShiftFunction
        typedef bp::class_< SireMM::CLJSoftIntraShiftFunction, bp::bases< SireMM::CLJSoftIntraFunction, SireMM::CLJIntraFunction, SireMM::CLJCutoffFunction, SireMM::CLJFunction, SireBase::Property > > CLJSoftIntraShiftFunction_exposer_t;
        CLJSoftIntraShiftFunction_exposer_t CLJSoftIntraShiftFunction_exposer = CLJSoftIntraShiftFunction_exposer_t( "CLJSoftIntraShiftFunction", bp::init< >() );
        bp::scope CLJSoftIntraShiftFunction_scope( CLJSoftIntraShiftFunction_exposer );
        CLJSoftIntraShiftFunction_exposer.def( bp::init< SireUnits::Dimension::Length >(( bp::arg("cutoff") )) );
        CLJSoftIntraShiftFunction_exposer.def( bp::init< SireUnits::Dimension::Length, SireUnits::Dimension::Length >(( bp::arg("coul_cutoff"), bp::arg("lj_cutoff") )) );
        CLJSoftIntraShiftFunction_exposer.def( bp::init< SireVol::Space const &, SireUnits::Dimension::Length >(( bp::arg("space"), bp::arg("cutoff") )) );
        CLJSoftIntraShiftFunction_exposer.def( bp::init< SireVol::Space const &, SireUnits::Dimension::Length, SireUnits::Dimension::Length >(( bp::arg("space"), bp::arg("coul_cutoff"), bp::arg("lj_cutoff") )) );
        CLJSoftIntraShiftFunction_exposer.def( bp::init< SireUnits::Dimension::Length, SireMM::CLJFunction::COMBINING_RULES >(( bp::arg("cutoff"), bp::arg("combining_rules") )) );
        CLJSoftIntraShiftFunction_exposer.def( bp::init< SireUnits::Dimension::Length, SireUnits::Dimension::Length, SireMM::CLJFunction::COMBINING_RULES >(( bp::arg("coul_cutoff"), bp::arg("lj_cutoff"), bp::arg("combining_rules") )) );
        CLJSoftIntraShiftFunction_exposer.def( bp::init< SireVol::Space const &, SireMM::CLJFunction::COMBINING_RULES >(( bp::arg("space"), bp::arg("combining_rules") )) );
        CLJSoftIntraShiftFunction_exposer.def( bp::init< SireVol::Space const &, SireUnits::Dimension::Length, SireMM::CLJFunction::COMBINING_RULES >(( bp::arg("space"), bp::arg("cutoff"), bp::arg("combining_rules") )) );
        CLJSoftIntraShiftFunction_exposer.def( bp::init< SireVol::Space const &, SireUnits::Dimension::Length, SireUnits::Dimension::Length, SireMM::CLJFunction::COMBINING_RULES >(( bp::arg("space"), bp::arg("coul_cutoff"), bp::arg("lj_cutoff"), bp::arg("combining_rules") )) );
        CLJSoftIntraShiftFunction_exposer.def( bp::init< SireMM::CLJSoftIntraShiftFunction const & >(( bp::arg("other") )) );
        { //::SireMM::CLJSoftIntraShiftFunction::defaultShiftFunction
        
            typedef ::SireMM::CLJFunctionPtr ( *defaultShiftFunction_function_type )(  );
            defaultShiftFunction_function_type defaultShiftFunction_function_value( &::SireMM::CLJSoftIntraShiftFunction::defaultShiftFunction );
            
            CLJSoftIntraShiftFunction_exposer.def( 
                "defaultShiftFunction"
                , defaultShiftFunction_function_value );
        
        }
        CLJSoftIntraShiftFunction_exposer.def( bp::self != bp::self );
        { //::SireMM::CLJSoftIntraShiftFunction::operator=
        
            typedef ::SireMM::CLJSoftIntraShiftFunction & ( ::SireMM::CLJSoftIntraShiftFunction::*assign_function_type )( ::SireMM::CLJSoftIntraShiftFunction const & ) ;
            assign_function_type assign_function_value( &::SireMM::CLJSoftIntraShiftFunction::operator= );
            
            CLJSoftIntraShiftFunction_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        CLJSoftIntraShiftFunction_exposer.def( bp::self == bp::self );
        { //::SireMM::CLJSoftIntraShiftFunction::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMM::CLJSoftIntraShiftFunction::typeName );
            
            CLJSoftIntraShiftFunction_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireMM::CLJSoftIntraShiftFunction::what
        
            typedef char const * ( ::SireMM::CLJSoftIntraShiftFunction::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireMM::CLJSoftIntraShiftFunction::what );
            
            CLJSoftIntraShiftFunction_exposer.def( 
                "what"
                , what_function_value );
        
        }
        CLJSoftIntraShiftFunction_exposer.staticmethod( "defaultShiftFunction" );
        CLJSoftIntraShiftFunction_exposer.staticmethod( "typeName" );
        CLJSoftIntraShiftFunction_exposer.def( "__copy__", &__copy__);
        CLJSoftIntraShiftFunction_exposer.def( "__deepcopy__", &__copy__);
        CLJSoftIntraShiftFunction_exposer.def( "clone", &__copy__);
        CLJSoftIntraShiftFunction_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::CLJSoftIntraShiftFunction >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        CLJSoftIntraShiftFunction_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::CLJSoftIntraShiftFunction >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        CLJSoftIntraShiftFunction_exposer.def( "__str__", &__str__< ::SireMM::CLJSoftIntraShiftFunction > );
        CLJSoftIntraShiftFunction_exposer.def( "__repr__", &__str__< ::SireMM::CLJSoftIntraShiftFunction > );
    }

}

//.........这里部分代码省略.........
        PotentialTable_exposer.def( -bp::self );
        PotentialTable_exposer.def( bp::self / bp::other< double >() );
        { //::SireFF::PotentialTable::operator=
        
            typedef ::SireFF::PotentialTable & ( ::SireFF::PotentialTable::*assign_function_type)( ::SireFF::PotentialTable const & ) ;
            assign_function_type assign_function_value( &::SireFF::PotentialTable::operator= );
            
            PotentialTable_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >()
                , "" );
        
        }
        { //::SireFF::PotentialTable::operator=
        
            typedef ::SireFF::PotentialTable & ( ::SireFF::PotentialTable::*assign_function_type)( ::SireUnits::Dimension::MolarEnergy const & ) ;
            assign_function_type assign_function_value( &::SireFF::PotentialTable::operator= );
            
            PotentialTable_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("potential") )
                , bp::return_self< >()
                , "" );
        
        }
        PotentialTable_exposer.def( bp::self == bp::self );
        { //::SireFF::PotentialTable::setAll
        
            typedef void ( ::SireFF::PotentialTable::*setAll_function_type)( ::SireUnits::Dimension::MolarEnergy const & ) ;
            setAll_function_type setAll_function_value( &::SireFF::PotentialTable::setAll );
            
            PotentialTable_exposer.def( 
                "setAll"
                , setAll_function_value
                , ( bp::arg("potential") )
                , "Set the potential at all atom and grid points equal to potential" );
        
        }
        { //::SireFF::PotentialTable::subtract
        
            typedef void ( ::SireFF::PotentialTable::*subtract_function_type)( ::SireFF::PotentialTable const & ) ;
            subtract_function_type subtract_function_value( &::SireFF::PotentialTable::subtract );
            
            PotentialTable_exposer.def( 
                "subtract"
                , subtract_function_value
                , ( bp::arg("other") )
                , "Subtract the contents of the table other from this table. This will only\nsubtract the potentials for the molecules  grids that are in both tables" );
        
        }
        { //::SireFF::PotentialTable::subtract
        
            typedef void ( ::SireFF::PotentialTable::*subtract_function_type)( ::SireUnits::Dimension::MolarEnergy const & ) ;
            subtract_function_type subtract_function_value( &::SireFF::PotentialTable::subtract );
            
            PotentialTable_exposer.def( 
                "subtract"
                , subtract_function_value
                , ( bp::arg("potential") )
                , "Subtract the potential potential from all of the atom  grid points in this table" );
        
        }
        { //::SireFF::PotentialTable::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireFF::PotentialTable::typeName );
            
            PotentialTable_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        { //::SireFF::PotentialTable::what
        
            typedef char const * ( ::SireFF::PotentialTable::*what_function_type)(  ) const;
            what_function_type what_function_value( &::SireFF::PotentialTable::what );
            
            PotentialTable_exposer.def( 
                "what"
                , what_function_value
                , "" );
        
        }
        PotentialTable_exposer.staticmethod( "typeName" );
        PotentialTable_exposer.def( "__copy__", &__copy__);
        PotentialTable_exposer.def( "__deepcopy__", &__copy__);
        PotentialTable_exposer.def( "clone", &__copy__);
        PotentialTable_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireFF::PotentialTable >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        PotentialTable_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireFF::PotentialTable >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        PotentialTable_exposer.def( "__str__", &pvt_get_name);
        PotentialTable_exposer.def( "__repr__", &pvt_get_name);
    }

}

//.........这里部分代码省略.........
                "force"
                , force_function_value
                , ( bp::arg("forcetable"), bp::arg("symbol"), bp::arg("scale_force")=1 ) );

        }
        InterGroupLJFF_exposer.def( bp::self != bp::self );
        {   //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::operator=

            typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
            typedef ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > & ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*assign_function_type )( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > const & ) ;
            assign_function_type assign_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::operator= );

            InterGroupLJFF_exposer.def(
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );

        }
        InterGroupLJFF_exposer.def( bp::self == bp::self );
        {   //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::potential

            typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
            typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*potential_function_type )( ::SireFF::PotentialTable &,double ) ;
            potential_function_type potential_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::potential );

            InterGroupLJFF_exposer.def(
                "potential"
                , potential_function_value
                , ( bp::arg("potentialtable"), bp::arg("scale_potential")=1 ) );

        }
        {   //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::potential

            typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
            typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*potential_function_type )( ::SireFF::PotentialTable &,::SireCAS::Symbol const &,double ) ;
            potential_function_type potential_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::potential );

            InterGroupLJFF_exposer.def(
                "potential"
                , potential_function_value
                , ( bp::arg("potentialtable"), bp::arg("component"), bp::arg("scale_potential")=1 ) );

        }
        {   //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::potential

            typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
            typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*potential_function_type )( ::SireFF::PotentialTable &,::SireFF::Probe const &,double ) ;
            potential_function_type potential_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::potential );

            InterGroupLJFF_exposer.def(
                "potential"
                , potential_function_value
                , ( bp::arg("potentialtable"), bp::arg("probe"), bp::arg("scale_potential")=1 ) );

        }
        {   //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::potential

            typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
            typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*potential_function_type )( ::SireFF::PotentialTable &,::SireCAS::Symbol const &,::SireFF::Probe const &,double ) ;
            potential_function_type potential_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::potential );

            InterGroupLJFF_exposer.def(
                "potential"
                , potential_function_value
                , ( bp::arg("potentialtable"), bp::arg("component"), bp::arg("probe"), bp::arg("scale_potential")=1 ) );

        }
        {   //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::typeName

            typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::typeName );

            InterGroupLJFF_exposer.def(
                "typeName"
                , typeName_function_value );

        }
        {   //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::what

            typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
            typedef char const * ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::what );

            InterGroupLJFF_exposer.def(
                "what"
                , what_function_value );

        }
        InterGroupLJFF_exposer.staticmethod( "typeName" );
        InterGroupLJFF_exposer.def( "__copy__", &__copy__);
        InterGroupLJFF_exposer.def( "__deepcopy__", &__copy__);
        InterGroupLJFF_exposer.def( "clone", &__copy__);
        InterGroupLJFF_exposer.def( "__str__", &__str__< ::SireFF::Inter2B2G3DFF<SireMM::LJPotentialInterface<SireMM::InterLJPotential> > > );
        InterGroupLJFF_exposer.def( "__repr__", &__str__< ::SireFF::Inter2B2G3DFF<SireMM::LJPotentialInterface<SireMM::InterLJPotential> > > );
        InterGroupLJFF_exposer.def( "__len__", &__len_count< ::SireFF::Inter2B2G3DFF<SireMM::LJPotentialInterface<SireMM::InterLJPotential> > > );
    }

}