自学教程：C++ typeName_function_value函数代码示例

//.........这里部分代码省略.........                "assign"                , assign_function_value                , ( bp::arg("other") )                , bp::return_self< >()                , "" );                }        ComponentGradients_exposer.def( bp::self == bp::self );        { //::SireAnalysis::ComponentGradients::temperature                    typedef ::SireUnits::Dimension::Temperature ( ::SireAnalysis::ComponentGradients::*temperature_function_type)(  ) const;            temperature_function_type temperature_function_value( &::SireAnalysis::ComponentGradients::temperature );                        ComponentGradients_exposer.def(                 "temperature"                , temperature_function_value                , "Return the temperature at which all of the components were collected" );                }        { //::SireAnalysis::ComponentGradients::toString                    typedef ::QString ( ::SireAnalysis::ComponentGradients::*toString_function_type)(  ) const;            toString_function_type toString_function_value( &::SireAnalysis::ComponentGradients::toString );                        ComponentGradients_exposer.def(                 "toString"                , toString_function_value                , "" );                }        { //::SireAnalysis::ComponentGradients::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireAnalysis::ComponentGradients::typeName );                        ComponentGradients_exposer.def(                 "typeName"                , typeName_function_value                , "" );                }        { //::SireAnalysis::ComponentGradients::values                    typedef ::QVector< SireAnalysis::DataPoint > ( ::SireAnalysis::ComponentGradients::*values_function_type)( int ) const;            values_function_type values_function_value( &::SireAnalysis::ComponentGradients::values );                        ComponentGradients_exposer.def(                 "values"                , values_function_value                , ( bp::arg("i") )                , "Return the actual values of the free energy gradients of the ith component" );                }        { //::SireAnalysis::ComponentGradients::viewAt                    typedef ::SireMol::PartialMolecule ( ::SireAnalysis::ComponentGradients::*viewAt_function_type)( int ) const;            viewAt_function_type viewAt_function_value( &::SireAnalysis::ComponentGradients::viewAt );                        ComponentGradients_exposer.def(                 "viewAt"                , viewAt_function_value                , ( bp::arg("i") )                , "Return the ith view that corresponds to the ith free energy component./nNote that this returns the view in the numerically first (lowest) lambda/nvalue. Use viewAt(int i, double lamval) if you want to specify the lambda/nvalue from which you want to extract the view." );                }        { //::SireAnalysis::ComponentGradients::viewAt

//.........这里部分代码省略.........                "calculateCharges"                , calculateCharges_function_value                , ( bp::arg("molecule") ) );                }        { //::Squire::QMProgram::chargeCommandFile                    typedef ::QString ( ::Squire::QMProgram::*chargeCommandFile_function_type )( ::SireMol::Molecule const & ) const;            chargeCommandFile_function_type chargeCommandFile_function_value( &::Squire::QMProgram::chargeCommandFile );                        QMProgram_exposer.def(                 "chargeCommandFile"                , chargeCommandFile_function_value                , ( bp::arg("molecule") ) );                }        { //::Squire::QMProgram::chargeCommandFile                    typedef ::QString ( ::Squire::QMProgram::*chargeCommandFile_function_type )( ::SireMol::Molecule const &,::SireBase::PropertyMap const & ) const;            chargeCommandFile_function_type chargeCommandFile_function_value( &::Squire::QMProgram::chargeCommandFile );                        QMProgram_exposer.def(                 "chargeCommandFile"                , chargeCommandFile_function_value                , ( bp::arg("molecule"), bp::arg("map") ) );                }        { //::Squire::QMProgram::null                    typedef ::Squire::NullQM const & ( *null_function_type )(  );            null_function_type null_function_value( &::Squire::QMProgram::null );                        QMProgram_exposer.def(                 "null"                , null_function_value                , bp::return_value_policy<bp::clone_const_reference>() );                }        { //::Squire::QMProgram::numberOfMMAtomsLimit                    typedef int ( ::Squire::QMProgram::*numberOfMMAtomsLimit_function_type )(  ) const;            numberOfMMAtomsLimit_function_type numberOfMMAtomsLimit_function_value( &::Squire::QMProgram::numberOfMMAtomsLimit );                        QMProgram_exposer.def(                 "numberOfMMAtomsLimit"                , numberOfMMAtomsLimit_function_value );                }        { //::Squire::QMProgram::numberOfMMAtomsLimit                    typedef int ( ::Squire::QMProgram::*numberOfMMAtomsLimit_function_type )( int ) const;            numberOfMMAtomsLimit_function_type numberOfMMAtomsLimit_function_value( &::Squire::QMProgram::numberOfMMAtomsLimit );                        QMProgram_exposer.def(                 "numberOfMMAtomsLimit"                , numberOfMMAtomsLimit_function_value                , ( bp::arg("num_qm_atoms") ) );                }        { //::Squire::QMProgram::supportsGaussianCharges                    typedef bool ( ::Squire::QMProgram::*supportsGaussianCharges_function_type )(  ) const;            supportsGaussianCharges_function_type supportsGaussianCharges_function_value( &::Squire::QMProgram::supportsGaussianCharges );                        QMProgram_exposer.def(                 "supportsGaussianCharges"                , supportsGaussianCharges_function_value );                }        { //::Squire::QMProgram::supportsLatticeCharges                    typedef bool ( ::Squire::QMProgram::*supportsLatticeCharges_function_type )(  ) const;            supportsLatticeCharges_function_type supportsLatticeCharges_function_value( &::Squire::QMProgram::supportsLatticeCharges );                        QMProgram_exposer.def(                 "supportsLatticeCharges"                , supportsLatticeCharges_function_value );                }        { //::Squire::QMProgram::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::Squire::QMProgram::typeName );                        QMProgram_exposer.def(                 "typeName"                , typeName_function_value );                }        QMProgram_exposer.staticmethod( "null" );        QMProgram_exposer.staticmethod( "typeName" );        QMProgram_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::Squire::QMProgram >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        QMProgram_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::Squire::QMProgram >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        QMProgram_exposer.def( "__str__", &__str__< ::Squire::QMProgram > );        QMProgram_exposer.def( "__repr__", &__str__< ::Squire::QMProgram > );    }}

void register_SupraSubMove_class(){    { //::SireMove::SupraSubMove        typedef bp::class_< SireMove::SupraSubMove, bp::bases< SireBase::Property >, boost::noncopyable > SupraSubMove_exposer_t;        SupraSubMove_exposer_t SupraSubMove_exposer = SupraSubMove_exposer_t( "SupraSubMove", bp::no_init );        bp::scope SupraSubMove_scope( SupraSubMove_exposer );        { //::SireMove::SupraSubMove::clearStatistics                    typedef void ( ::SireMove::SupraSubMove::*clearStatistics_function_type )(  ) ;            clearStatistics_function_type clearStatistics_function_value( &::SireMove::SupraSubMove::clearStatistics );                        SupraSubMove_exposer.def(                 "clearStatistics"                , clearStatistics_function_value );                }        { //::SireMove::SupraSubMove::move                    typedef void ( ::SireMove::SupraSubMove::*move_function_type )( ::SireMove::SupraSubSystem &,int,int,bool ) ;            move_function_type move_function_value( &::SireMove::SupraSubMove::move );                        SupraSubMove_exposer.def(                 "move"                , move_function_value                , ( bp::arg("system"), bp::arg("n_supra_moves"), bp::arg("n_supra_moves_per_block"), bp::arg("record_stats")=(bool)(true) ) );                }        { //::SireMove::SupraSubMove::null                    typedef ::SireMove::NullSupraSubMove const & ( *null_function_type )(  );            null_function_type null_function_value( &::SireMove::SupraSubMove::null );                        SupraSubMove_exposer.def(                 "null"                , null_function_value                , bp::return_value_policy< bp::copy_const_reference >() );                }        { //::SireMove::SupraSubMove::toString                    typedef ::QString ( ::SireMove::SupraSubMove::*toString_function_type )(  ) const;            toString_function_type toString_function_value( &::SireMove::SupraSubMove::toString );                        SupraSubMove_exposer.def(                 "toString"                , toString_function_value );                }        { //::SireMove::SupraSubMove::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireMove::SupraSubMove::typeName );                        SupraSubMove_exposer.def(                 "typeName"                , typeName_function_value );                }        SupraSubMove_exposer.staticmethod( "null" );        SupraSubMove_exposer.staticmethod( "typeName" );        SupraSubMove_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMove::SupraSubMove >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        SupraSubMove_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMove::SupraSubMove >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        SupraSubMove_exposer.def( "__str__", &__str__< ::SireMove::SupraSubMove > );        SupraSubMove_exposer.def( "__repr__", &__str__< ::SireMove::SupraSubMove > );    }}

void register_SingleComponent_class(){    { //::SireFF::SingleComponent        typedef bp::class_< SireFF::SingleComponent, bp::bases< SireFF::FFComponent, SireCAS::Symbol, SireCAS::ExBase > > SingleComponent_exposer_t;        SingleComponent_exposer_t SingleComponent_exposer = SingleComponent_exposer_t( "SingleComponent", bp::init< bp::optional< SireFF::FFName const & > >(( bp::arg("ffname")=SireFF::FFName() )) );        bp::scope SingleComponent_scope( SingleComponent_exposer );        SingleComponent_exposer.def( bp::init< SireFF::FFName const &, QString const & >(( bp::arg("ffname"), bp::arg("suffix") )) );        SingleComponent_exposer.def( bp::init< SireCAS::Symbol const & >(( bp::arg("symbol") )) );        SingleComponent_exposer.def( bp::init< SireFF::SingleComponent const & >(( bp::arg("other") )) );        { //::SireFF::SingleComponent::changeEnergy                    typedef void ( ::SireFF::SingleComponent::*changeEnergy_function_type )( ::SireFF::FF &,::SireFF::SingleEnergy const & ) const;            changeEnergy_function_type changeEnergy_function_value( &::SireFF::SingleComponent::changeEnergy );                        SingleComponent_exposer.def(                 "changeEnergy"                , changeEnergy_function_value                , ( bp::arg("ff"), bp::arg("nrg") ) );                }        { //::SireFF::SingleComponent::setEnergy                    typedef void ( ::SireFF::SingleComponent::*setEnergy_function_type )( ::SireFF::FF &,::SireFF::SingleEnergy const & ) const;            setEnergy_function_type setEnergy_function_value( &::SireFF::SingleComponent::setEnergy );                        SingleComponent_exposer.def(                 "setEnergy"                , setEnergy_function_value                , ( bp::arg("ff"), bp::arg("nrg") ) );                }        { //::SireFF::SingleComponent::symbols                    typedef ::SireCAS::Symbols ( ::SireFF::SingleComponent::*symbols_function_type )(  ) const;            symbols_function_type symbols_function_value( &::SireFF::SingleComponent::symbols );                        SingleComponent_exposer.def(                 "symbols"                , symbols_function_value );                }        { //::SireFF::SingleComponent::total                    typedef ::SireFF::SingleComponent const & ( ::SireFF::SingleComponent::*total_function_type )(  ) const;            total_function_type total_function_value( &::SireFF::SingleComponent::total );                        SingleComponent_exposer.def(                 "total"                , total_function_value                , bp::return_value_policy<bp::clone_const_reference>() );                }        { //::SireFF::SingleComponent::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireFF::SingleComponent::typeName );                        SingleComponent_exposer.def(                 "typeName"                , typeName_function_value );                }        { //::SireFF::SingleComponent::what                    typedef char const * ( ::SireFF::SingleComponent::*what_function_type )(  ) const;            what_function_type what_function_value( &::SireFF::SingleComponent::what );                        SingleComponent_exposer.def(                 "what"                , what_function_value );                }        SingleComponent_exposer.staticmethod( "typeName" );        SingleComponent_exposer.def( "__copy__", &__copy__);        SingleComponent_exposer.def( "__deepcopy__", &__copy__);        SingleComponent_exposer.def( "clone", &__copy__);        SingleComponent_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireFF::SingleComponent >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        SingleComponent_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireFF::SingleComponent >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        SingleComponent_exposer.def( "__str__", &__str__< ::SireFF::SingleComponent > );        SingleComponent_exposer.def( "__repr__", &__str__< ::SireFF::SingleComponent > );    }}

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

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

//.........这里部分代码省略.........            FEP_exposer.def(                 "set"                , set_function_value                , ( bp::arg("i"), bp::arg("windows"), bp::arg("deltas") )                , "Set the deltas for the ith iteration" );                }        { //::SireAnalysis::FEP::set                    typedef void ( ::SireAnalysis::FEP::*set_function_type)( int,::QList< double > const &,::QMap< double, SireMaths::FreeEnergyAverage > const &,::QMap< double, SireMaths::FreeEnergyAverage > const & ) ;            set_function_type set_function_value( &::SireAnalysis::FEP::set );                        FEP_exposer.def(                 "set"                , set_function_value                , ( bp::arg("i"), bp::arg("windows"), bp::arg("forwards_deltas"), bp::arg("backwards_deltas") )                , "Set the deltas for the ith iteration" );                }        { //::SireAnalysis::FEP::set                    typedef void ( ::SireAnalysis::FEP::*set_function_type)( int,::SireAnalysis::FEPDeltas const & ) ;            set_function_type set_function_value( &::SireAnalysis::FEP::set );                        FEP_exposer.def(                 "set"                , set_function_value                , ( bp::arg("i"), bp::arg("deltas") )                , "Set the deltas for the ith iteration" );                }        { //::SireAnalysis::FEP::size                    typedef int ( ::SireAnalysis::FEP::*size_function_type)(  ) const;            size_function_type size_function_value( &::SireAnalysis::FEP::size );                        FEP_exposer.def(                 "size"                , size_function_value                , "Return the number of iterations" );                }        { //::SireAnalysis::FEP::toString                    typedef ::QString ( ::SireAnalysis::FEP::*toString_function_type)(  ) const;            toString_function_type toString_function_value( &::SireAnalysis::FEP::toString );                        FEP_exposer.def(                 "toString"                , toString_function_value                , "" );                }        { //::SireAnalysis::FEP::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireAnalysis::FEP::typeName );                        FEP_exposer.def(                 "typeName"                , typeName_function_value                , "" );                }        { //::SireAnalysis::FEP::what                    typedef char const * ( ::SireAnalysis::FEP::*what_function_type)(  ) const;            what_function_type what_function_value( &::SireAnalysis::FEP::what );                        FEP_exposer.def(                 "what"                , what_function_value                , "" );                }        { //::SireAnalysis::FEP::windows                    typedef ::QList< double > ( ::SireAnalysis::FEP::*windows_function_type)(  ) const;            windows_function_type windows_function_value( &::SireAnalysis::FEP::windows );                        FEP_exposer.def(                 "windows"                , windows_function_value                , "Return the value of all windows" );                }        FEP_exposer.staticmethod( "typeName" );        FEP_exposer.def( "__copy__", &__copy__);        FEP_exposer.def( "__deepcopy__", &__copy__);        FEP_exposer.def( "clone", &__copy__);        FEP_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireAnalysis::FEP >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        FEP_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireAnalysis::FEP >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        FEP_exposer.def( "__str__", &__str__< ::SireAnalysis::FEP > );        FEP_exposer.def( "__repr__", &__str__< ::SireAnalysis::FEP > );        FEP_exposer.def( "__len__", &__len_size< ::SireAnalysis::FEP > );    }}

//.........这里部分代码省略.........                "point1"                , point1_function_value                , bp::return_value_policy<bp::clone_const_reference>()                , "Return the second point" );                }        { //::SireMM::DistanceRestraint::r                    typedef ::SireCAS::Symbol const & ( *r_function_type )(  );            r_function_type r_function_value( &::SireMM::DistanceRestraint::r );                        DistanceRestraint_exposer.def(                 "r"                , r_function_value                , bp::return_value_policy<bp::clone_const_reference>()                , "Return the symbol that represents the distance between the/ntwo points (r)" );                }        { //::SireMM::DistanceRestraint::setSpace                    typedef void ( ::SireMM::DistanceRestraint::*setSpace_function_type)( ::SireVol::Space const & ) ;            setSpace_function_type setSpace_function_value( &::SireMM::DistanceRestraint::setSpace );                        DistanceRestraint_exposer.def(                 "setSpace"                , setSpace_function_value                , ( bp::arg("space") )                , "Set the space used to evaluate the energy of this restraint/nThrow: SireVol::incompatible_space/n" );                }        { //::SireMM::DistanceRestraint::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireMM::DistanceRestraint::typeName );                        DistanceRestraint_exposer.def(                 "typeName"                , typeName_function_value                , "" );                }        { //::SireMM::DistanceRestraint::update                    typedef void ( ::SireMM::DistanceRestraint::*update_function_type)( ::SireMol::MoleculeData const & ) ;            update_function_type update_function_value( &::SireMM::DistanceRestraint::update );                        DistanceRestraint_exposer.def(                 "update"                , update_function_value                , ( bp::arg("moldata") )                , "Update the points of this restraint using new molecule data from moldata/nThrow: SireBase::missing_property/nThrow: SireError::invalid_cast/nThrow: SireError::incompatible_error/n" );                }        { //::SireMM::DistanceRestraint::update                    typedef void ( ::SireMM::DistanceRestraint::*update_function_type)( ::SireMol::Molecules const & ) ;            update_function_type update_function_value( &::SireMM::DistanceRestraint::update );                        DistanceRestraint_exposer.def(                 "update"                , update_function_value                , ( bp::arg("molecules") )                , "Update the points of this restraint using new molecule data from molecules/nThrow: SireBase::missing_property/nThrow: SireError::invalid_cast/nThrow: SireError::incompatible_error/n" );                }        { //::SireMM::DistanceRestraint::usesMoleculesIn

void register_ZmatrixMaker_class(){    { //::SireIO::ZmatrixMaker        typedef bp::class_< SireIO::ZmatrixMaker > ZmatrixMaker_exposer_t;        ZmatrixMaker_exposer_t ZmatrixMaker_exposer = ZmatrixMaker_exposer_t( "ZmatrixMaker", "This class is used to read templates describing how a residue can be moved using zmatrix moves/nand to create a zmatrix property for residues whose template is available./n/nAuthor: Julien Michel/n", bp::init< >("Default constructor") );        bp::scope ZmatrixMaker_scope( ZmatrixMaker_exposer );        { //::SireIO::ZmatrixMaker::applyTemplates                    typedef ::SireMol::Molecule ( ::SireIO::ZmatrixMaker::*applyTemplates_function_type)( ::SireMol::Molecule & ) ;            applyTemplates_function_type applyTemplates_function_value( &::SireIO::ZmatrixMaker::applyTemplates );                        ZmatrixMaker_exposer.def(                 "applyTemplates"                , applyTemplates_function_value                , ( bp::arg("molecule") )                , "Add the property z-matrix to molecule" );                }        { //::SireIO::ZmatrixMaker::loadTemplates                    typedef void ( ::SireIO::ZmatrixMaker::*loadTemplates_function_type)( ::QString const & ) ;            loadTemplates_function_type loadTemplates_function_value( &::SireIO::ZmatrixMaker::loadTemplates );                        ZmatrixMaker_exposer.def(                 "loadTemplates"                , loadTemplates_function_value                , ( bp::arg("templatesfile") )                , "Read the contents of an input file to create a set of ZmatrixResidues" );                }        { //::SireIO::ZmatrixMaker::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireIO::ZmatrixMaker::typeName );                        ZmatrixMaker_exposer.def(                 "typeName"                , typeName_function_value                , "" );                }        { //::SireIO::ZmatrixMaker::what                    typedef char const * ( ::SireIO::ZmatrixMaker::*what_function_type)(  ) const;            what_function_type what_function_value( &::SireIO::ZmatrixMaker::what );                        ZmatrixMaker_exposer.def(                 "what"                , what_function_value                , "" );                }        ZmatrixMaker_exposer.staticmethod( "typeName" );        ZmatrixMaker_exposer.def( "__copy__", &__copy__);        ZmatrixMaker_exposer.def( "__deepcopy__", &__copy__);        ZmatrixMaker_exposer.def( "clone", &__copy__);        ZmatrixMaker_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireIO::ZmatrixMaker >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        ZmatrixMaker_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireIO::ZmatrixMaker >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        ZmatrixMaker_exposer.def( "__str__", &pvt_get_name);        ZmatrixMaker_exposer.def( "__repr__", &pvt_get_name);    }}

void register_ArcCsc_class(){    { //::SireCAS::ArcCsc        typedef bp::class_< SireCAS::ArcCsc, bp::bases< SireCAS::SingleFunc, SireCAS::ExBase > > ArcCsc_exposer_t;        ArcCsc_exposer_t ArcCsc_exposer = ArcCsc_exposer_t( "ArcCsc", bp::init< >() );        bp::scope ArcCsc_scope( ArcCsc_exposer );        ArcCsc_exposer.def( bp::init< SireCAS::Expression const & >(( bp::arg("ex") )) );        ArcCsc_exposer.def( bp::init< SireCAS::ArcCsc const & >(( bp::arg("other") )) );        { //::SireCAS::ArcCsc::evaluate                    typedef double ( ::SireCAS::ArcCsc::*evaluate_function_type )( ::SireCAS::Values const & ) const;            evaluate_function_type evaluate_function_value( &::SireCAS::ArcCsc::evaluate );                        ArcCsc_exposer.def(                 "evaluate"                , evaluate_function_value                , ( bp::arg("values") ) );                }        { //::SireCAS::ArcCsc::evaluate                    typedef ::SireMaths::Complex ( ::SireCAS::ArcCsc::*evaluate_function_type )( ::SireCAS::ComplexValues const & ) const;            evaluate_function_type evaluate_function_value( &::SireCAS::ArcCsc::evaluate );                        ArcCsc_exposer.def(                 "evaluate"                , evaluate_function_value                , ( bp::arg("values") ) );                }        ArcCsc_exposer.def( bp::self == bp::other< SireCAS::ExBase >() );        { //::SireCAS::ArcCsc::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireCAS::ArcCsc::typeName );                        ArcCsc_exposer.def(                 "typeName"                , typeName_function_value );                }        { //::SireCAS::ArcCsc::what                    typedef char const * ( ::SireCAS::ArcCsc::*what_function_type )(  ) const;            what_function_type what_function_value( &::SireCAS::ArcCsc::what );                        ArcCsc_exposer.def(                 "what"                , what_function_value );                }        ArcCsc_exposer.staticmethod( "typeName" );        ArcCsc_exposer.def( "__copy__", &__copy__);        ArcCsc_exposer.def( "__deepcopy__", &__copy__);        ArcCsc_exposer.def( "clone", &__copy__);        ArcCsc_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::ArcCsc >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        ArcCsc_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::ArcCsc >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        ArcCsc_exposer.def( "__str__", &__str__< ::SireCAS::ArcCsc > );        ArcCsc_exposer.def( "__repr__", &__str__< ::SireCAS::ArcCsc > );    }}

void register_GreaterOrEqualThan_class(){    { //::SireCAS::GreaterOrEqualThan        typedef bp::class_< SireCAS::GreaterOrEqualThan, bp::bases< SireCAS::Condition, SireCAS::ExBase > > GreaterOrEqualThan_exposer_t;        GreaterOrEqualThan_exposer_t GreaterOrEqualThan_exposer = GreaterOrEqualThan_exposer_t( "GreaterOrEqualThan", "This is a conditional function that returns whether or/nnot the first expression is greater than or equal to/nthe second expression/n/nAuthor: Christopher Woods/n", bp::init< >("Constructor") );        bp::scope GreaterOrEqualThan_scope( GreaterOrEqualThan_exposer );        GreaterOrEqualThan_exposer.def( bp::init< SireCAS::Expression const &, SireCAS::Expression const & >(( bp::arg("left_hand_side"), bp::arg("right_hand_side") ), "Construct to compare left_hand_side with right_hand_side") );        GreaterOrEqualThan_exposer.def( bp::init< SireCAS::GreaterOrEqualThan const & >(( bp::arg("other") ), "Copy constructor") );        { //::SireCAS::GreaterOrEqualThan::alwaysFalse                    typedef bool ( ::SireCAS::GreaterOrEqualThan::*alwaysFalse_function_type)(  ) const;            alwaysFalse_function_type alwaysFalse_function_value( &::SireCAS::GreaterOrEqualThan::alwaysFalse );                        GreaterOrEqualThan_exposer.def(                 "alwaysFalse"                , alwaysFalse_function_value                , "Return whether or not we can be absolutely sure that this/ncondition will always be false. Note that this doesnt try/ntoo hard, so some things that are always false may not/nbe reported here as being always false, e.g. x > x + 1" );                }        { //::SireCAS::GreaterOrEqualThan::alwaysTrue                    typedef bool ( ::SireCAS::GreaterOrEqualThan::*alwaysTrue_function_type)(  ) const;            alwaysTrue_function_type alwaysTrue_function_value( &::SireCAS::GreaterOrEqualThan::alwaysTrue );                        GreaterOrEqualThan_exposer.def(                 "alwaysTrue"                , alwaysTrue_function_value                , "Return whether or not we can be absolutely sure that this/ncondition will always be true. Note that this doesnt try/ntoo hard, so some things that are always true may not/nbe reported here as being always true, e.g. x + 1 > x" );                }        { //::SireCAS::GreaterOrEqualThan::operator=                    typedef ::SireCAS::GreaterOrEqualThan & ( ::SireCAS::GreaterOrEqualThan::*assign_function_type)( ::SireCAS::GreaterOrEqualThan const & ) ;            assign_function_type assign_function_value( &::SireCAS::GreaterOrEqualThan::operator= );                        GreaterOrEqualThan_exposer.def(                 "assign"                , assign_function_value                , ( bp::arg("other") )                , bp::return_self< >()                , "" );                }        GreaterOrEqualThan_exposer.def( bp::self == bp::self );        GreaterOrEqualThan_exposer.def( bp::self == bp::other< SireCAS::ExBase >() );        { //::SireCAS::GreaterOrEqualThan::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireCAS::GreaterOrEqualThan::typeName );                        GreaterOrEqualThan_exposer.def(                 "typeName"                , typeName_function_value                , "" );                }        { //::SireCAS::GreaterOrEqualThan::what                    typedef char const * ( ::SireCAS::GreaterOrEqualThan::*what_function_type)(  ) const;            what_function_type what_function_value( &::SireCAS::GreaterOrEqualThan::what );                        GreaterOrEqualThan_exposer.def(                 "what"                , what_function_value                , "" );                }        GreaterOrEqualThan_exposer.staticmethod( "typeName" );        GreaterOrEqualThan_exposer.def( "__copy__", &__copy__);        GreaterOrEqualThan_exposer.def( "__deepcopy__", &__copy__);        GreaterOrEqualThan_exposer.def( "clone", &__copy__);        GreaterOrEqualThan_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::GreaterOrEqualThan >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        GreaterOrEqualThan_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::GreaterOrEqualThan >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        GreaterOrEqualThan_exposer.def( "__str__", &__str__< ::SireCAS::GreaterOrEqualThan > );        GreaterOrEqualThan_exposer.def( "__repr__", &__str__< ::SireCAS::GreaterOrEqualThan > );        GreaterOrEqualThan_exposer.def( "__hash__", &::SireCAS::GreaterOrEqualThan::hash );    }}

//.........这里部分代码省略.........                , recalculate_function_value                , ( bp::arg("cgarray") )                , "Recalculate the AABox so that it completely encloses the CoordGroups/nin the array cgarray" );                }        { //::SireVol::AABox::recalculate                    typedef void ( ::SireVol::AABox::*recalculate_function_type)( ::SireVol::CoordGroupArrayArray const & ) ;            recalculate_function_type recalculate_function_value( &::SireVol::AABox::recalculate );                        AABox_exposer.def(                 "recalculate"                , recalculate_function_value                , ( bp::arg("cgarrays") )                , "Recalculate the AABox so that it completely encloses the CoordGroups/nin the arrays cgarrays" );                }        { //::SireVol::AABox::recalculate                    typedef void ( ::SireVol::AABox::*recalculate_function_type)( ::QVector< SireMaths::Vector > const & ) ;            recalculate_function_type recalculate_function_value( &::SireVol::AABox::recalculate );                        AABox_exposer.def(                 "recalculate"                , recalculate_function_value                , ( bp::arg("coordinates") )                , "Recalculate the AABox so that it completely encloses the coordinates" );                }        { //::SireVol::AABox::toString                    typedef ::QString ( ::SireVol::AABox::*toString_function_type)(  ) const;            toString_function_type toString_function_value( &::SireVol::AABox::toString );                        AABox_exposer.def(                 "toString"                , toString_function_value                , "Return a string representation of this AABox" );                }        { //::SireVol::AABox::translate                    typedef void ( ::SireVol::AABox::*translate_function_type)( ::SireMaths::Vector const & ) ;            translate_function_type translate_function_value( &::SireVol::AABox::translate );                        AABox_exposer.def(                 "translate"                , translate_function_value                , ( bp::arg("delta") )                , "Translate this AABox by delta" );                }        { //::SireVol::AABox::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireVol::AABox::typeName );                        AABox_exposer.def(                 "typeName"                , typeName_function_value                , "" );                }        { //::SireVol::AABox::what                    typedef char const * ( ::SireVol::AABox::*what_function_type)(  ) const;            what_function_type what_function_value( &::SireVol::AABox::what );                        AABox_exposer.def(                 "what"                , what_function_value                , "" );                }        { //::SireVol::AABox::withinDistance                    typedef bool ( ::SireVol::AABox::*withinDistance_function_type)( double,::SireVol::AABox const & ) const;            withinDistance_function_type withinDistance_function_value( &::SireVol::AABox::withinDistance );                        AABox_exposer.def(                 "withinDistance"                , withinDistance_function_value                , ( bp::arg("dist"), bp::arg("box") )                , "Return whether or not this box is within dist of box box./n(using infinite cartesian axes)" );                }        AABox_exposer.staticmethod( "from" );        AABox_exposer.staticmethod( "typeName" );        AABox_exposer.def( "__copy__", &__copy__);        AABox_exposer.def( "__deepcopy__", &__copy__);        AABox_exposer.def( "clone", &__copy__);        AABox_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::AABox >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        AABox_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::AABox >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        AABox_exposer.def( "__str__", &__str__< ::SireVol::AABox > );        AABox_exposer.def( "__repr__", &__str__< ::SireVol::AABox > );    }}

//.........这里部分代码省略.........                , takeAt_function_value                , ( bp::arg("i") ) );                }        { //::SireBase::PropertyList::takeFirst                    typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*takeFirst_function_type )(  ) ;            takeFirst_function_type takeFirst_function_value( &::SireBase::PropertyList::takeFirst );                        PropertyList_exposer.def(                 "takeFirst"                , takeFirst_function_value );                }        { //::SireBase::PropertyList::takeLast                    typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*takeLast_function_type )(  ) ;            takeLast_function_type takeLast_function_value( &::SireBase::PropertyList::takeLast );                        PropertyList_exposer.def(                 "takeLast"                , takeLast_function_value );                }        { //::SireBase::PropertyList::toList                    typedef ::QList< SireBase::PropPtr< SireBase::Property > > ( ::SireBase::PropertyList::*toList_function_type )(  ) const;            toList_function_type toList_function_value( &::SireBase::PropertyList::toList );                        PropertyList_exposer.def(                 "toList"                , toList_function_value );                }        { //::SireBase::PropertyList::toString                    typedef ::QString ( ::SireBase::PropertyList::*toString_function_type )(  ) const;            toString_function_type toString_function_value( &::SireBase::PropertyList::toString );                        PropertyList_exposer.def(                 "toString"                , toString_function_value );                }        { //::SireBase::PropertyList::toVector                    typedef ::QVector< SireBase::PropPtr< SireBase::Property > > ( ::SireBase::PropertyList::*toVector_function_type )(  ) const;            toVector_function_type toVector_function_value( &::SireBase::PropertyList::toVector );                        PropertyList_exposer.def(                 "toVector"                , toVector_function_value );                }        { //::SireBase::PropertyList::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireBase::PropertyList::typeName );                        PropertyList_exposer.def(                 "typeName"                , typeName_function_value );                }        { //::SireBase::PropertyList::value                    typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*value_function_type )( int ) const;            value_function_type value_function_value( &::SireBase::PropertyList::value );                        PropertyList_exposer.def(                 "value"                , value_function_value                , ( bp::arg("i") ) );                }        { //::SireBase::PropertyList::value                    typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*value_function_type )( int,::SireBase::Property const & ) const;            value_function_type value_function_value( &::SireBase::PropertyList::value );                        PropertyList_exposer.def(                 "value"                , value_function_value                , ( bp::arg("i"), bp::arg("default_value") ) );                }        PropertyList_exposer.staticmethod( "typeName" );        PropertyList_exposer.def( "__copy__", &__copy__);        PropertyList_exposer.def( "__deepcopy__", &__copy__);        PropertyList_exposer.def( "clone", &__copy__);        PropertyList_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::PropertyList >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        PropertyList_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::PropertyList >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        PropertyList_exposer.def( "__str__", &__str__< ::SireBase::PropertyList > );        PropertyList_exposer.def( "__repr__", &__str__< ::SireBase::PropertyList > );        PropertyList_exposer.def( "__len__", &__len_size< ::SireBase::PropertyList > );    }}

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

void register_Tinker_class(){    { //::SireIO::Tinker        typedef bp::class_< SireIO::Tinker, bp::bases< SireIO::IOBase, SireBase::Property > > Tinker_exposer_t;        Tinker_exposer_t Tinker_exposer = Tinker_exposer_t( "Tinker", "This class is used to read and write files in Tinker format/n/nAuthor: Christopher Woods/n", bp::init< >("Constructor") );        bp::scope Tinker_scope( Tinker_exposer );        Tinker_exposer.def( bp::init< SireIO::Tinker const & >(( bp::arg("other") ), "Copy constructor") );        { //::SireIO::Tinker::loadParameters                    typedef void ( ::SireIO::Tinker::*loadParameters_function_type)( ::QString const & ) ;            loadParameters_function_type loadParameters_function_value( &::SireIO::Tinker::loadParameters );                        Tinker_exposer.def(                 "loadParameters"                , loadParameters_function_value                , ( bp::arg("prmfile") )                , "Load the parameter file prmfile into this reader. This will allow/nthe reader to parameterise the molecules as they are being read" );                }        Tinker_exposer.def( bp::self != bp::self );        { //::SireIO::Tinker::operator=                    typedef ::SireIO::Tinker & ( ::SireIO::Tinker::*assign_function_type)( ::SireIO::Tinker const & ) ;            assign_function_type assign_function_value( &::SireIO::Tinker::operator= );                        Tinker_exposer.def(                 "assign"                , assign_function_value                , ( bp::arg("other") )                , bp::return_self< >()                , "" );                }        Tinker_exposer.def( bp::self == bp::self );        { //::SireIO::Tinker::parameters                    typedef ::SireIO::TinkerParameters const & ( *parameters_function_type )(  );            parameters_function_type parameters_function_value( &::SireIO::Tinker::parameters );                        Tinker_exposer.def(                 "parameters"                , parameters_function_value                , bp::return_value_policy< bp::copy_const_reference >()                , "Return the default parameters used by this IO object" );                }        { //::SireIO::Tinker::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireIO::Tinker::typeName );                        Tinker_exposer.def(                 "typeName"                , typeName_function_value                , "" );                }        Tinker_exposer.staticmethod( "parameters" );        Tinker_exposer.staticmethod( "typeName" );        Tinker_exposer.def( "__copy__", &__copy__);        Tinker_exposer.def( "__deepcopy__", &__copy__);        Tinker_exposer.def( "clone", &__copy__);        Tinker_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireIO::Tinker >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        Tinker_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireIO::Tinker >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        Tinker_exposer.def( "__str__", &__str__< ::SireIO::Tinker > );        Tinker_exposer.def( "__repr__", &__str__< ::SireIO::Tinker > );    }}

void register_PolariseChargesFF_class(){    { //::SireSystem::PolariseChargesFF        typedef bp::class_< SireSystem::PolariseChargesFF, bp::bases< SireFF::G1FF, SireFF::FF, SireMol::MolGroupsBase, SireBase::Property > > PolariseChargesFF_exposer_t;        PolariseChargesFF_exposer_t PolariseChargesFF_exposer = PolariseChargesFF_exposer_t( "PolariseChargesFF", bp::init< >() );        bp::scope PolariseChargesFF_scope( PolariseChargesFF_exposer );        PolariseChargesFF_exposer.def( bp::init< SireSystem::PolariseCharges const & >(( bp::arg("constraint") )) );        PolariseChargesFF_exposer.def( bp::init< QString const &, SireSystem::PolariseCharges const & >(( bp::arg("name"), bp::arg("constraint") )) );        PolariseChargesFF_exposer.def( bp::init< SireSystem::PolariseChargesFF const & >(( bp::arg("other") )) );        { //::SireSystem::PolariseChargesFF::components                    typedef ::SireFF::SingleComponent const & ( ::SireSystem::PolariseChargesFF::*components_function_type )(  ) const;            components_function_type components_function_value( &::SireSystem::PolariseChargesFF::components );                        PolariseChargesFF_exposer.def(                 "components"                , components_function_value                , bp::return_value_policy<bp::clone_const_reference>() );                }        { //::SireSystem::PolariseChargesFF::containsProperty                    typedef bool ( ::SireSystem::PolariseChargesFF::*containsProperty_function_type )( ::QString const & ) const;            containsProperty_function_type containsProperty_function_value( &::SireSystem::PolariseChargesFF::containsProperty );                        PolariseChargesFF_exposer.def(                 "containsProperty"                , containsProperty_function_value                , ( bp::arg("name") ) );                }        { //::SireSystem::PolariseChargesFF::mustNowRecalculateFromScratch                    typedef void ( ::SireSystem::PolariseChargesFF::*mustNowRecalculateFromScratch_function_type )(  ) ;            mustNowRecalculateFromScratch_function_type mustNowRecalculateFromScratch_function_value( &::SireSystem::PolariseChargesFF::mustNowRecalculateFromScratch );                        PolariseChargesFF_exposer.def(                 "mustNowRecalculateFromScratch"                , mustNowRecalculateFromScratch_function_value );                }        PolariseChargesFF_exposer.def( bp::self != bp::self );        { //::SireSystem::PolariseChargesFF::operator=                    typedef ::SireSystem::PolariseChargesFF & ( ::SireSystem::PolariseChargesFF::*assign_function_type )( ::SireSystem::PolariseChargesFF const & ) ;            assign_function_type assign_function_value( &::SireSystem::PolariseChargesFF::operator= );                        PolariseChargesFF_exposer.def(                 "assign"                , assign_function_value                , ( bp::arg("other") )                , bp::return_self< >() );                }        PolariseChargesFF_exposer.def( bp::self == bp::self );        { //::SireSystem::PolariseChargesFF::properties                    typedef ::SireBase::Properties const & ( ::SireSystem::PolariseChargesFF::*properties_function_type )(  ) const;            properties_function_type properties_function_value( &::SireSystem::PolariseChargesFF::properties );                        PolariseChargesFF_exposer.def(                 "properties"                , properties_function_value                , bp::return_value_policy< bp::copy_const_reference >() );                }        { //::SireSystem::PolariseChargesFF::property                    typedef ::SireBase::Property const & ( ::SireSystem::PolariseChargesFF::*property_function_type )( ::QString const & ) const;            property_function_type property_function_value( &::SireSystem::PolariseChargesFF::property );                        PolariseChargesFF_exposer.def(                 "property"                , property_function_value                , ( bp::arg("name") )                , bp::return_value_policy<bp::clone_const_reference>() );                }        { //::SireSystem::PolariseChargesFF::setProperty                    typedef bool ( ::SireSystem::PolariseChargesFF::*setProperty_function_type )( ::QString const &,::SireBase::Property const & ) ;            setProperty_function_type setProperty_function_value( &::SireSystem::PolariseChargesFF::setProperty );                        PolariseChargesFF_exposer.def(                 "setProperty"                , setProperty_function_value                , ( bp::arg("name"), bp::arg("property") ) );                }        { //::SireSystem::PolariseChargesFF::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireSystem::PolariseChargesFF::typeName );                        PolariseChargesFF_exposer.def(                 "typeName"                , typeName_function_value );                }        PolariseChargesFF_exposer.staticmethod( "typeName" );//.........这里部分代码省略.........

//.........这里部分代码省略.........                , ( bp::arg("i") ) );                }        { //::SireVol::BoxPatching::patchBox                    typedef ::SireVol::AABox ( ::SireVol::BoxPatching::*patchBox_function_type )( ::SireMaths::Vector const & ) const;            patchBox_function_type patchBox_function_value( &::SireVol::BoxPatching::patchBox );                        BoxPatching_exposer.def(                 "patchBox"                , patchBox_function_value                , ( bp::arg("point") ) );                }        { //::SireVol::BoxPatching::patchDimension                    typedef ::SireMaths::Vector ( ::SireVol::BoxPatching::*patchDimension_function_type )(  ) const;            patchDimension_function_type patchDimension_function_value( &::SireVol::BoxPatching::patchDimension );                        BoxPatching_exposer.def(                 "patchDimension"                , patchDimension_function_value );                }        { //::SireVol::BoxPatching::patchIndex                    typedef int ( ::SireVol::BoxPatching::*patchIndex_function_type )( ::SireMaths::Vector const & ) const;            patchIndex_function_type patchIndex_function_value( &::SireVol::BoxPatching::patchIndex );                        BoxPatching_exposer.def(                 "patchIndex"                , patchIndex_function_value                , ( bp::arg("point") ) );                }        { //::SireVol::BoxPatching::patchIndexAndCenter                    typedef ::QPair< int, SireMaths::Vector > ( ::SireVol::BoxPatching::*patchIndexAndCenter_function_type )( ::SireMaths::Vector const & ) const;            patchIndexAndCenter_function_type patchIndexAndCenter_function_value( &::SireVol::BoxPatching::patchIndexAndCenter );                        BoxPatching_exposer.def(                 "patchIndexAndCenter"                , patchIndexAndCenter_function_value                , ( bp::arg("point") ) );                }        { //::SireVol::BoxPatching::patchSize                    typedef ::SireUnits::Dimension::Length ( ::SireVol::BoxPatching::*patchSize_function_type )(  ) const;            patchSize_function_type patchSize_function_value( &::SireVol::BoxPatching::patchSize );                        BoxPatching_exposer.def(                 "patchSize"                , patchSize_function_value );                }        { //::SireVol::BoxPatching::repatch                    typedef ::SireVol::PatchingPtr ( ::SireVol::BoxPatching::*repatch_function_type )( ::SireVol::Space const & ) const;            repatch_function_type repatch_function_value( &::SireVol::BoxPatching::repatch );                        BoxPatching_exposer.def(                 "repatch"                , repatch_function_value                , ( bp::arg("new_space") ) );                }        { //::SireVol::BoxPatching::toString                    typedef ::QString ( ::SireVol::BoxPatching::*toString_function_type )(  ) const;            toString_function_type toString_function_value( &::SireVol::BoxPatching::toString );                        BoxPatching_exposer.def(                 "toString"                , toString_function_value );                }        { //::SireVol::BoxPatching::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireVol::BoxPatching::typeName );                        BoxPatching_exposer.def(                 "typeName"                , typeName_function_value );                }        BoxPatching_exposer.staticmethod( "typeName" );        BoxPatching_exposer.def( "__copy__", &__copy__);        BoxPatching_exposer.def( "__deepcopy__", &__copy__);        BoxPatching_exposer.def( "clone", &__copy__);        BoxPatching_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::BoxPatching >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        BoxPatching_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::BoxPatching >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        BoxPatching_exposer.def( "__str__", &__str__< ::SireVol::BoxPatching > );        BoxPatching_exposer.def( "__repr__", &__str__< ::SireVol::BoxPatching > );    }}

//.........这里部分代码省略.........                }        { //::Squire::PP_GTO::Q_minus_D                    typedef ::SireMaths::Vector const & ( ::Squire::PP_GTO::*Q_minus_D_function_type )(  ) const;            Q_minus_D_function_type Q_minus_D_function_value( &::Squire::PP_GTO::Q_minus_D );                        PP_GTO_exposer.def(                 "Q_minus_D"                , Q_minus_D_function_value                , bp::return_value_policy< bp::copy_const_reference >() );                }        { //::Squire::PP_GTO::angularMomentum0                    typedef int ( ::Squire::PP_GTO::*angularMomentum0_function_type )(  ) const;            angularMomentum0_function_type angularMomentum0_function_value( &::Squire::PP_GTO::angularMomentum0 );                        PP_GTO_exposer.def(                 "angularMomentum0"                , angularMomentum0_function_value );                }        { //::Squire::PP_GTO::angularMomentum1                    typedef int ( ::Squire::PP_GTO::*angularMomentum1_function_type )(  ) const;            angularMomentum1_function_type angularMomentum1_function_value( &::Squire::PP_GTO::angularMomentum1 );                        PP_GTO_exposer.def(                 "angularMomentum1"                , angularMomentum1_function_value );                }        { //::Squire::PP_GTO::nOrbitals0                    typedef int ( ::Squire::PP_GTO::*nOrbitals0_function_type )(  ) const;            nOrbitals0_function_type nOrbitals0_function_value( &::Squire::PP_GTO::nOrbitals0 );                        PP_GTO_exposer.def(                 "nOrbitals0"                , nOrbitals0_function_value );                }        { //::Squire::PP_GTO::nOrbitals1                    typedef int ( ::Squire::PP_GTO::*nOrbitals1_function_type )(  ) const;            nOrbitals1_function_type nOrbitals1_function_value( &::Squire::PP_GTO::nOrbitals1 );                        PP_GTO_exposer.def(                 "nOrbitals1"                , nOrbitals1_function_value );                }        PP_GTO_exposer.def( bp::self != bp::self );        { //::Squire::PP_GTO::operator=                    typedef ::Squire::PP_GTO & ( ::Squire::PP_GTO::*assign_function_type )( ::Squire::PP_GTO const & ) ;            assign_function_type assign_function_value( &::Squire::PP_GTO::operator= );                        PP_GTO_exposer.def(                 "assign"                , assign_function_value                , ( bp::arg("other") )                , bp::return_self< >() );                }        PP_GTO_exposer.def( bp::self == bp::self );        { //::Squire::PP_GTO::scale                    typedef double ( ::Squire::PP_GTO::*scale_function_type )(  ) const;            scale_function_type scale_function_value( &::Squire::PP_GTO::scale );                        PP_GTO_exposer.def(                 "scale"                , scale_function_value );                }        { //::Squire::PP_GTO::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::Squire::PP_GTO::typeName );                        PP_GTO_exposer.def(                 "typeName"                , typeName_function_value );                }        PP_GTO_exposer.staticmethod( "typeName" );        PP_GTO_exposer.def( "__copy__", &__copy__);        PP_GTO_exposer.def( "__deepcopy__", &__copy__);        PP_GTO_exposer.def( "clone", &__copy__);        PP_GTO_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::Squire::PP_GTO >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        PP_GTO_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::Squire::PP_GTO >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        PP_GTO_exposer.def( "__str__", &__str__< ::Squire::PP_GTO > );        PP_GTO_exposer.def( "__repr__", &__str__< ::Squire::PP_GTO > );    }}

//.........这里部分代码省略.........        }        { //::SireFF::MolPotentialTable::subtract                    typedef bool ( ::SireFF::MolPotentialTable::*subtract_function_type )( ::SireMol::CGAtomIdx const &,::SireUnits::Dimension::MolarEnergy const & ) ;            subtract_function_type subtract_function_value( &::SireFF::MolPotentialTable::subtract );                        MolPotentialTable_exposer.def(                 "subtract"                , subtract_function_value                , ( bp::arg("cgatomidx"), bp::arg("potential") ) );                }        { //::SireFF::MolPotentialTable::subtract                    typedef bool ( ::SireFF::MolPotentialTable::*subtract_function_type )( ::SireMol::AtomSelection const &,::SireUnits::Dimension::MolarEnergy const & ) ;            subtract_function_type subtract_function_value( &::SireFF::MolPotentialTable::subtract );                        MolPotentialTable_exposer.def(                 "subtract"                , subtract_function_value                , ( bp::arg("selected_atoms"), bp::arg("potential") ) );                }        { //::SireFF::MolPotentialTable::subtract                    typedef void ( ::SireFF::MolPotentialTable::*subtract_function_type )( ::SireFF::MolPotentialTable const & ) ;            subtract_function_type subtract_function_value( &::SireFF::MolPotentialTable::subtract );                        MolPotentialTable_exposer.def(                 "subtract"                , subtract_function_value                , ( bp::arg("other") ) );                }        { //::SireFF::MolPotentialTable::subtract                    typedef void ( ::SireFF::MolPotentialTable::*subtract_function_type )( ::SireUnits::Dimension::MolarEnergy const & ) ;            subtract_function_type subtract_function_value( &::SireFF::MolPotentialTable::subtract );                        MolPotentialTable_exposer.def(                 "subtract"                , subtract_function_value                , ( bp::arg("potential") ) );                }        { //::SireFF::MolPotentialTable::toVector                    typedef ::QVector< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > > ( ::SireFF::MolPotentialTable::*toVector_function_type )(  ) const;            toVector_function_type toVector_function_value( &::SireFF::MolPotentialTable::toVector );                        MolPotentialTable_exposer.def(                 "toVector"                , toVector_function_value );                }        { //::SireFF::MolPotentialTable::toVector                    typedef ::QVector< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > > ( ::SireFF::MolPotentialTable::*toVector_function_type )( ::SireMol::AtomSelection const & ) const;            toVector_function_type toVector_function_value( &::SireFF::MolPotentialTable::toVector );                        MolPotentialTable_exposer.def(                 "toVector"                , toVector_function_value                , ( bp::arg("selection") ) );                }        { //::SireFF::MolPotentialTable::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireFF::MolPotentialTable::typeName );                        MolPotentialTable_exposer.def(                 "typeName"                , typeName_function_value );                }        { //::SireFF::MolPotentialTable::what                    typedef char const * ( ::SireFF::MolPotentialTable::*what_function_type )(  ) const;            what_function_type what_function_value( &::SireFF::MolPotentialTable::what );                        MolPotentialTable_exposer.def(                 "what"                , what_function_value );                }        MolPotentialTable_exposer.staticmethod( "typeName" );        MolPotentialTable_exposer.def( "__copy__", &__copy__);        MolPotentialTable_exposer.def( "__deepcopy__", &__copy__);        MolPotentialTable_exposer.def( "clone", &__copy__);        MolPotentialTable_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireFF::MolPotentialTable >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        MolPotentialTable_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireFF::MolPotentialTable >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        MolPotentialTable_exposer.def( "__str__", &__str__< ::SireFF::MolPotentialTable > );        MolPotentialTable_exposer.def( "__repr__", &__str__< ::SireFF::MolPotentialTable > );        MolPotentialTable_exposer.def( "__len__", &__len_size< ::SireFF::MolPotentialTable > );    }}

//.........这里部分代码省略.........                , hasYErrorRange_function_value                , "Return whether or not there is an error range on the x value" );                }        DataPoint_exposer.def( bp::self != bp::self );        { //::SireAnalysis::DataPoint::operator=                    typedef ::SireAnalysis::DataPoint & ( ::SireAnalysis::DataPoint::*assign_function_type)( ::SireAnalysis::DataPoint const & ) ;            assign_function_type assign_function_value( &::SireAnalysis::DataPoint::operator= );                        DataPoint_exposer.def(                 "assign"                , assign_function_value                , ( bp::arg("other") )                , bp::return_self< >()                , "" );                }        DataPoint_exposer.def( bp::self == bp::self );        { //::SireAnalysis::DataPoint::toString                    typedef ::QString ( ::SireAnalysis::DataPoint::*toString_function_type)(  ) const;            toString_function_type toString_function_value( &::SireAnalysis::DataPoint::toString );                        DataPoint_exposer.def(                 "toString"                , toString_function_value                , "" );                }        { //::SireAnalysis::DataPoint::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireAnalysis::DataPoint::typeName );                        DataPoint_exposer.def(                 "typeName"                , typeName_function_value                , "" );                }        { //::SireAnalysis::DataPoint::what                    typedef char const * ( ::SireAnalysis::DataPoint::*what_function_type)(  ) const;            what_function_type what_function_value( &::SireAnalysis::DataPoint::what );                        DataPoint_exposer.def(                 "what"                , what_function_value                , "" );                }        { //::SireAnalysis::DataPoint::x                    typedef double ( ::SireAnalysis::DataPoint::*x_function_type)(  ) const;            x_function_type x_function_value( &::SireAnalysis::DataPoint::x );                        DataPoint_exposer.def(                 "x"                , x_function_value                , "Return the x value of the point" );                }        { //::SireAnalysis::DataPoint::xError                    typedef double ( ::SireAnalysis::DataPoint::*xError_function_type)(  ) const;

//.........这里部分代码省略.........                        Specify_SysID__exposer.def(                 "__call__"                , __call___function_value                , ( bp::arg("i") )                , "" );                }        { //::SireID::Specify< SireSystem::SysID >::operator()                    typedef SireID::Specify< SireSystem::SysID > exported_class_t;            typedef ::SireID::Specify< SireSystem::SysID > ( ::SireID::Specify< SireSystem::SysID >::*__call___function_type)( int,int ) const;            __call___function_type __call___function_value( &::SireID::Specify< SireSystem::SysID >::operator() );                        Specify_SysID__exposer.def(                 "__call__"                , __call___function_value                , ( bp::arg("i"), bp::arg("j") )                , "" );                }        { //::SireID::Specify< SireSystem::SysID >::operator=                    typedef SireID::Specify< SireSystem::SysID > exported_class_t;            typedef ::SireID::Specify< SireSystem::SysID > & ( ::SireID::Specify< SireSystem::SysID >::*assign_function_type)( ::SireID::Specify< SireSystem::SysID > const & ) ;            assign_function_type assign_function_value( &::SireID::Specify< SireSystem::SysID >::operator= );                        Specify_SysID__exposer.def(                 "assign"                , assign_function_value                , ( bp::arg("other") )                , bp::return_self< >()                , "" );                }        Specify_SysID__exposer.def( bp::self == bp::self );        Specify_SysID__exposer.def( bp::self == bp::other< SireID::ID >() );        { //::SireID::Specify< SireSystem::SysID >::operator[]                    typedef SireID::Specify< SireSystem::SysID > exported_class_t;            typedef ::SireID::Specify< SireSystem::SysID > ( ::SireID::Specify< SireSystem::SysID >::*__getitem___function_type)( int ) const;            __getitem___function_type __getitem___function_value( &::SireID::Specify< SireSystem::SysID >::operator[] );                        Specify_SysID__exposer.def(                 "__getitem__"                , __getitem___function_value                , ( bp::arg("i") )                , "" );                }        { //::SireID::Specify< SireSystem::SysID >::toString                    typedef SireID::Specify< SireSystem::SysID > exported_class_t;            typedef ::QString ( ::SireID::Specify< SireSystem::SysID >::*toString_function_type)(  ) const;            toString_function_type toString_function_value( &::SireID::Specify< SireSystem::SysID >::toString );                        Specify_SysID__exposer.def(                 "toString"                , toString_function_value                , "" );                }        { //::SireID::Specify< SireSystem::SysID >::typeName                    typedef SireID::Specify< SireSystem::SysID > exported_class_t;            typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireID::Specify< SireSystem::SysID >::typeName );                        Specify_SysID__exposer.def(                 "typeName"                , typeName_function_value                , "" );                }        { //::SireID::Specify< SireSystem::SysID >::what                    typedef SireID::Specify< SireSystem::SysID > exported_class_t;            typedef char const * ( ::SireID::Specify< SireSystem::SysID >::*what_function_type)(  ) const;            what_function_type what_function_value( &::SireID::Specify< SireSystem::SysID >::what );                        Specify_SysID__exposer.def(                 "what"                , what_function_value                , "" );                }        Specify_SysID__exposer.staticmethod( "typeName" );        Specify_SysID__exposer.def( "__copy__", &__copy__);        Specify_SysID__exposer.def( "__deepcopy__", &__copy__);        Specify_SysID__exposer.def( "clone", &__copy__);        Specify_SysID__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireID::Specify<SireSystem::SysID> >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        Specify_SysID__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireID::Specify<SireSystem::SysID> >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        Specify_SysID__exposer.def( "__str__", &__str__< ::SireID::Specify<SireSystem::SysID> > );        Specify_SysID__exposer.def( "__repr__", &__str__< ::SireID::Specify<SireSystem::SysID> > );        Specify_SysID__exposer.def( "__hash__", &::SireID::Specify<SireSystem::SysID>::hash );    }}

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

//.........这里部分代码省略.........                    typedef void ( ::SireMove::Replicas::*setSubSystem_function_type )( ::SireMove::SupraSubSystem const & ) ;            setSubSystem_function_type setSubSystem_function_value( &::SireMove::Replicas::setSubSystem );                        Replicas_exposer.def(                 "setSubSystem"                , setSubSystem_function_value                , ( bp::arg("subsystem") ) );                }        { //::SireMove::Replicas::setSubSystem                    typedef void ( ::SireMove::Replicas::*setSubSystem_function_type )( int,::SireSystem::System const & ) ;            setSubSystem_function_type setSubSystem_function_value( &::SireMove::Replicas::setSubSystem );                        Replicas_exposer.def(                 "setSubSystem"                , setSubSystem_function_value                , ( bp::arg("i"), bp::arg("system") ) );                }        { //::SireMove::Replicas::setSubSystem                    typedef void ( ::SireMove::Replicas::*setSubSystem_function_type )( int,::SireMove::SupraSubSystem const & ) ;            setSubSystem_function_type setSubSystem_function_value( &::SireMove::Replicas::setSubSystem );                        Replicas_exposer.def(                 "setSubSystem"                , setSubSystem_function_value                , ( bp::arg("i"), bp::arg("subsystem") ) );                }        { //::SireMove::Replicas::setTemperature                    typedef void ( ::SireMove::Replicas::*setTemperature_function_type )( ::SireUnits::Dimension::Temperature const & ) ;            setTemperature_function_type setTemperature_function_value( &::SireMove::Replicas::setTemperature );                        Replicas_exposer.def(                 "setTemperature"                , setTemperature_function_value                , ( bp::arg("temperature") ) );                }        { //::SireMove::Replicas::setTemperature                    typedef void ( ::SireMove::Replicas::*setTemperature_function_type )( int,::SireUnits::Dimension::Temperature const & ) ;            setTemperature_function_type setTemperature_function_value( &::SireMove::Replicas::setTemperature );                        Replicas_exposer.def(                 "setTemperature"                , setTemperature_function_value                , ( bp::arg("i"), bp::arg("temperature") ) );                }        { //::SireMove::Replicas::swapMolecules                    typedef void ( ::SireMove::Replicas::*swapMolecules_function_type )( int,int ) ;            swapMolecules_function_type swapMolecules_function_value( &::SireMove::Replicas::swapMolecules );                        Replicas_exposer.def(                 "swapMolecules"                , swapMolecules_function_value                , ( bp::arg("i"), bp::arg("j") ) );                }        { //::SireMove::Replicas::swapSystems                    typedef void ( ::SireMove::Replicas::*swapSystems_function_type )( int,int,bool ) ;            swapSystems_function_type swapSystems_function_value( &::SireMove::Replicas::swapSystems );                        Replicas_exposer.def(                 "swapSystems"                , swapSystems_function_value                , ( bp::arg("i"), bp::arg("j"), bp::arg("swap_monitors")=(bool)(true) ) );                }        { //::SireMove::Replicas::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireMove::Replicas::typeName );                        Replicas_exposer.def(                 "typeName"                , typeName_function_value );                }        Replicas_exposer.staticmethod( "typeName" );        Replicas_exposer.def( "__copy__", &__copy__);        Replicas_exposer.def( "__deepcopy__", &__copy__);        Replicas_exposer.def( "clone", &__copy__);        Replicas_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMove::Replicas >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        Replicas_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMove::Replicas >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        Replicas_exposer.def( "__str__", &__str__< ::SireMove::Replicas > );        Replicas_exposer.def( "__repr__", &__str__< ::SireMove::Replicas > );        Replicas_exposer.def( "__len__", &__len_size< ::SireMove::Replicas > );    }}

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 > );    }}

//.........这里部分代码省略.........                , assign_function_value                , ( bp::arg("other") )                , bp::return_self< >()                , "" );                }        IDAssigner_exposer.def( bp::self == bp::self );        { //::SireSystem::IDAssigner::points                    typedef ::QVector< SireBase::PropPtr< SireFF::Point > > ( ::SireSystem::IDAssigner::*points_function_type)(  ) const;            points_function_type points_function_value( &::SireSystem::IDAssigner::points );                        IDAssigner_exposer.def(                 "points"                , points_function_value                , "Return the points used to identify the molecules" );                }        { //::SireSystem::IDAssigner::propertyMap                    typedef ::SireBase::PropertyMap const & ( ::SireSystem::IDAssigner::*propertyMap_function_type)(  ) const;            propertyMap_function_type propertyMap_function_value( &::SireSystem::IDAssigner::propertyMap );                        IDAssigner_exposer.def(                 "propertyMap"                , propertyMap_function_value                , bp::return_value_policy< bp::copy_const_reference >()                , "Return the property map used to find the properties required/nby this constraint" );                }        { //::SireSystem::IDAssigner::space                    typedef ::SireVol::Space const & ( ::SireSystem::IDAssigner::*space_function_type)(  ) const;            space_function_type space_function_value( &::SireSystem::IDAssigner::space );                        IDAssigner_exposer.def(                 "space"                , space_function_value                , bp::return_value_policy<bp::clone_const_reference>()                , "Return the space used to calculate distances between the molecules/nand the identity points" );                }        { //::SireSystem::IDAssigner::toString                    typedef ::QString ( ::SireSystem::IDAssigner::*toString_function_type)(  ) const;            toString_function_type toString_function_value( &::SireSystem::IDAssigner::toString );                        IDAssigner_exposer.def(                 "toString"                , toString_function_value                , "Return a string representation of this assigner" );                }        { //::SireSystem::IDAssigner::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireSystem::IDAssigner::typeName );                        IDAssigner_exposer.def(                 "typeName"                , typeName_function_value                , "" );                }        { //::SireSystem::IDAssigner::update                    typedef void ( ::SireSystem::IDAssigner::*update_function_type)( ::SireSystem::System const & ) ;            update_function_type update_function_value( &::SireSystem::IDAssigner::update );                        IDAssigner_exposer.def(                 "update"                , update_function_value                , ( bp::arg("system") )                , "Update the assigner with the passed system." );                }        { //::SireSystem::IDAssigner::what                    typedef char const * ( ::SireSystem::IDAssigner::*what_function_type)(  ) const;            what_function_type what_function_value( &::SireSystem::IDAssigner::what );                        IDAssigner_exposer.def(                 "what"                , what_function_value                , "" );                }        IDAssigner_exposer.staticmethod( "typeName" );        IDAssigner_exposer.def( "__copy__", &__copy__);        IDAssigner_exposer.def( "__deepcopy__", &__copy__);        IDAssigner_exposer.def( "clone", &__copy__);        IDAssigner_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireSystem::IDAssigner >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        IDAssigner_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireSystem::IDAssigner >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        IDAssigner_exposer.def( "__str__", &__str__< ::SireSystem::IDAssigner > );        IDAssigner_exposer.def( "__repr__", &__str__< ::SireSystem::IDAssigner > );    }}

//.........这里部分代码省略.........                "force"                , force_function_value                , ( bp::arg("forcetable"), bp::arg("symbol"), bp::arg("scale_force")=1 ) );                }        InterGroupCLJFF_exposer.def( bp::self != bp::self );        { //::SireFF::Inter2B2G3DFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::operator=                    typedef SireFF::Inter2B2G3DFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > exported_class_t;            typedef ::SireFF::Inter2B2G3DFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > & ( ::SireFF::Inter2B2G3DFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::*assign_function_type )( ::SireFF::Inter2B2G3DFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > const & ) ;            assign_function_type assign_function_value( &::SireFF::Inter2B2G3DFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::operator= );                        InterGroupCLJFF_exposer.def(                 "assign"                , assign_function_value                , ( bp::arg("other") )                , bp::return_self< >() );                }        InterGroupCLJFF_exposer.def( bp::self == bp::self );        { //::SireFF::Inter2B2G3DFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::potential                    typedef SireFF::Inter2B2G3DFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > exported_class_t;            typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::*potential_function_type )( ::SireFF::PotentialTable &,double ) ;            potential_function_type potential_function_value( &::SireFF::Inter2B2G3DFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::potential );                        InterGroupCLJFF_exposer.def(                 "potential"                , potential_function_value                , ( bp::arg("potentialtable"), bp::arg("scale_potential")=1 ) );                }        { //::SireFF::Inter2B2G3DFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::potential                    typedef SireFF::Inter2B2G3DFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > exported_class_t;            typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::*potential_function_type )( ::SireFF::PotentialTable &,::SireCAS::Symbol const &,double ) ;            potential_function_type potential_function_value( &::SireFF::Inter2B2G3DFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::potential );                        InterGroupCLJFF_exposer.def(                 "potential"                , potential_function_value                , ( bp::arg("potentialtable"), bp::arg("component"), bp::arg("scale_potential")=1 ) );                }        { //::SireFF::Inter2B2G3DFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::potential                    typedef SireFF::Inter2B2G3DFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > exported_class_t;            typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::*potential_function_type )( ::SireFF::PotentialTable &,::SireFF::Probe const &,double ) ;            potential_function_type potential_function_value( &::SireFF::Inter2B2G3DFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::potential );                        InterGroupCLJFF_exposer.def(                 "potential"                , potential_function_value                , ( bp::arg("potentialtable"), bp::arg("probe"), bp::arg("scale_potential")=1 ) );                }        { //::SireFF::Inter2B2G3DFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::potential                    typedef SireFF::Inter2B2G3DFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > exported_class_t;            typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::*potential_function_type )( ::SireFF::PotentialTable &,::SireCAS::Symbol const &,::SireFF::Probe const &,double ) ;            potential_function_type potential_function_value( &::SireFF::Inter2B2G3DFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::potential );                        InterGroupCLJFF_exposer.def(                 "potential"                , potential_function_value                , ( bp::arg("potentialtable"), bp::arg("component"), bp::arg("probe"), bp::arg("scale_potential")=1 ) );                }        { //::SireFF::Inter2B2G3DFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::typeName                    typedef SireFF::Inter2B2G3DFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > exported_class_t;            typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireFF::Inter2B2G3DFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::typeName );                        InterGroupCLJFF_exposer.def(                 "typeName"                , typeName_function_value );                }        { //::SireFF::Inter2B2G3DFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::what                    typedef SireFF::Inter2B2G3DFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > exported_class_t;            typedef char const * ( ::SireFF::Inter2B2G3DFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::*what_function_type )(  ) const;            what_function_type what_function_value( &::SireFF::Inter2B2G3DFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::what );                        InterGroupCLJFF_exposer.def(                 "what"                , what_function_value );                }        InterGroupCLJFF_exposer.staticmethod( "typeName" );        InterGroupCLJFF_exposer.def( "__copy__", &__copy__);        InterGroupCLJFF_exposer.def( "__deepcopy__", &__copy__);        InterGroupCLJFF_exposer.def( "clone", &__copy__);        InterGroupCLJFF_exposer.def( "__str__", &__str__< ::SireFF::Inter2B2G3DFF<SireMM::CLJPotentialInterface<SireMM::InterCLJPotential> > > );        InterGroupCLJFF_exposer.def( "__repr__", &__str__< ::SireFF::Inter2B2G3DFF<SireMM::CLJPotentialInterface<SireMM::InterCLJPotential> > > );        InterGroupCLJFF_exposer.def( "__len__", &__len_count< ::SireFF::Inter2B2G3DFF<SireMM::CLJPotentialInterface<SireMM::InterCLJPotential> > > );    }}

//.........这里部分代码省略.........            typedef ::SireCAS::Symbol const & ( *r12_function_type )(  );            r12_function_type r12_function_value( &::SireSystem::AngleComponent::r12 );                        AngleComponent_exposer.def(                 "r12"                , r12_function_value                , bp::return_value_policy<bp::clone_const_reference>()                , "Return the symbol that represents the 1-2 distance" );                }        { //::SireSystem::AngleComponent::theta                    typedef ::SireCAS::Symbol const & ( *theta_function_type )(  );            theta_function_type theta_function_value( &::SireSystem::AngleComponent::theta );                        AngleComponent_exposer.def(                 "theta"                , theta_function_value                , bp::return_value_policy<bp::clone_const_reference>()                , "Return the symbol that represents the central angle between/nthe three points" );                }        { //::SireSystem::AngleComponent::theta012                    typedef ::SireCAS::Symbol const & ( *theta012_function_type )(  );            theta012_function_type theta012_function_value( &::SireSystem::AngleComponent::theta012 );                        AngleComponent_exposer.def(                 "theta012"                , theta012_function_value                , bp::return_value_policy<bp::clone_const_reference>()                , "Return the symbol that represents the angle 012 between/nthe three points" );                }        { //::SireSystem::AngleComponent::theta021                    typedef ::SireCAS::Symbol const & ( *theta021_function_type )(  );            theta021_function_type theta021_function_value( &::SireSystem::AngleComponent::theta021 );                        AngleComponent_exposer.def(                 "theta021"                , theta021_function_value                , bp::return_value_policy<bp::clone_const_reference>()                , "Return the symbol that represents the angle 021 between/nthe three points" );                }        { //::SireSystem::AngleComponent::theta102                    typedef ::SireCAS::Symbol const & ( *theta102_function_type )(  );            theta102_function_type theta102_function_value( &::SireSystem::AngleComponent::theta102 );                        AngleComponent_exposer.def(                 "theta102"                , theta102_function_value                , bp::return_value_policy<bp::clone_const_reference>()                , "Return the symbol that represents the angle 102 between/nthe three points" );                }        { //::SireSystem::AngleComponent::toString                    typedef ::QString ( ::SireSystem::AngleComponent::*toString_function_type)(  ) const;            toString_function_type toString_function_value( &::SireSystem::AngleComponent::toString );                        AngleComponent_exposer.def(                 "toString"                , toString_function_value                , "" );                }        { //::SireSystem::AngleComponent::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireSystem::AngleComponent::typeName );                        AngleComponent_exposer.def(                 "typeName"                , typeName_function_value                , "" );                }        AngleComponent_exposer.staticmethod( "r01" );        AngleComponent_exposer.staticmethod( "r02" );        AngleComponent_exposer.staticmethod( "r12" );        AngleComponent_exposer.staticmethod( "theta" );        AngleComponent_exposer.staticmethod( "theta012" );        AngleComponent_exposer.staticmethod( "theta021" );        AngleComponent_exposer.staticmethod( "theta102" );        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< ::SireSystem::AngleComponent >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        AngleComponent_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireSystem::AngleComponent >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        AngleComponent_exposer.def( "__str__", &__str__< ::SireSystem::AngleComponent > );        AngleComponent_exposer.def( "__repr__", &__str__< ::SireSystem::AngleComponent > );    }}

void register_Velocity3D_class(){    { //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >        typedef bp::class_< SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > > Velocity3D_exposer_t;        Velocity3D_exposer_t Velocity3D_exposer = Velocity3D_exposer_t( "Velocity3D", bp::init< >() );        bp::scope Velocity3D_scope( Velocity3D_exposer );        Velocity3D_exposer.def( bp::init< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & >(( bp::arg("val") )) );        Velocity3D_exposer.def( bp::init< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const &, SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const &, SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & >(( bp::arg("x"), bp::arg("y"), bp::arg("z") )) );        Velocity3D_exposer.def( bp::init< SireMaths::Vector const & >(( bp::arg("v") )) );        Velocity3D_exposer.def( bp::init< SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > const & >(( bp::arg("other") )) );        { //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::at                    typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;            typedef ::SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*at_function_type )( int ) const;            at_function_type at_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::at );                        Velocity3D_exposer.def(                 "at"                , at_function_value                , ( bp::arg("i") )                , bp::return_value_policy< bp::copy_const_reference >() );                }        { //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::count                    typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;            typedef int ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*count_function_type )(  ) const;            count_function_type count_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::count );                        Velocity3D_exposer.def(                 "count"                , count_function_value );                }        Velocity3D_exposer.def( bp::self != bp::self );        Velocity3D_exposer.def( bp::self * bp::other< double >() );        Velocity3D_exposer.def( bp::self + bp::self );        Velocity3D_exposer.def( -bp::self );        Velocity3D_exposer.def( bp::self - bp::self );        Velocity3D_exposer.def( bp::self / bp::other< double >() );        { //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::operator=                    typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;            typedef ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > & ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*assign_function_type )( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > const & ) ;            assign_function_type assign_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::operator= );                        Velocity3D_exposer.def(                 "assign"                , assign_function_value                , ( bp::arg("other") )                , bp::return_self< >() );                }        Velocity3D_exposer.def( bp::self == bp::self );        { //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::operator[]                    typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;            typedef ::SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*__getitem___function_type )( int ) const;            __getitem___function_type __getitem___function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::operator[] );                        Velocity3D_exposer.def(                 "__getitem__"                , __getitem___function_value                , ( bp::arg("i") )                , bp::return_value_policy< bp::copy_const_reference >() );                }        { //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::set                    typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;            typedef void ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*set_function_type )( int,::SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & ) ;            set_function_type set_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::set );                        Velocity3D_exposer.def(                 "set"                , set_function_value                , ( bp::arg("i"), bp::arg("value") ) );                }        { //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::toString                    typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;            typedef ::QString ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*toString_function_type )(  ) const;            toString_function_type toString_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::toString );                        Velocity3D_exposer.def(                 "toString"                , toString_function_value );                }        { //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::typeName                    typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;            typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::typeName );                        Velocity3D_exposer.def(                 "typeName"                , typeName_function_value );        //.........这里部分代码省略.........

//.........这里部分代码省略.........                , add_function_value                , ( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2"), bp::arg("symval3"), bp::arg("symval4"), bp::arg("symval5"), bp::arg("symval6"), bp::arg("symval7") )                , "Add the passed values" );                }        { //::SireCAS::ComplexValues::add                    typedef void ( ::SireCAS::ComplexValues::*add_function_type)( ::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const & ) ;            add_function_type add_function_value( &::SireCAS::ComplexValues::add );                        ComplexValues_exposer.def(                 "add"                , add_function_value                , ( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2"), bp::arg("symval3"), bp::arg("symval4"), bp::arg("symval5"), bp::arg("symval6"), bp::arg("symval7"), bp::arg("symval8") )                , "Add the passed values" );                }        { //::SireCAS::ComplexValues::add                    typedef void ( ::SireCAS::ComplexValues::*add_function_type)( ::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const & ) ;            add_function_type add_function_value( &::SireCAS::ComplexValues::add );                        ComplexValues_exposer.def(                 "add"                , add_function_value                , ( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2"), bp::arg("symval3"), bp::arg("symval4"), bp::arg("symval5"), bp::arg("symval6"), bp::arg("symval7"), bp::arg("symval8"), bp::arg("symval9") )                , "Add the passed values" );                }        { //::SireCAS::ComplexValues::set                    typedef void ( ::SireCAS::ComplexValues::*set_function_type)( ::SireCAS::Symbol const &,::SireMaths::Complex const & ) ;            set_function_type set_function_value( &::SireCAS::ComplexValues::set );                        ComplexValues_exposer.def(                 "set"                , set_function_value                , ( bp::arg("symbol"), bp::arg("value") )                , "" );                }        { //::SireCAS::ComplexValues::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireCAS::ComplexValues::typeName );                        ComplexValues_exposer.def(                 "typeName"                , typeName_function_value                , "" );                }        { //::SireCAS::ComplexValues::value                    typedef ::SireMaths::Complex ( ::SireCAS::ComplexValues::*value_function_type)( ::SireCAS::Symbol const & ) const;            value_function_type value_function_value( &::SireCAS::ComplexValues::value );                        ComplexValues_exposer.def(                 "value"                , value_function_value                , ( bp::arg("sym") )                , "Return the value of the Symbol with ID id, or 0.0 if there is no such symbol" );                }        { //::SireCAS::ComplexValues::values                    typedef ::QHash< unsigned int, SireMaths::Complex > const & ( ::SireCAS::ComplexValues::*values_function_type)(  ) const;            values_function_type values_function_value( &::SireCAS::ComplexValues::values );                        ComplexValues_exposer.def(                 "values"                , values_function_value                , bp::return_value_policy< bp::copy_const_reference >()                , "" );                }        { //::SireCAS::ComplexValues::what                    typedef char const * ( ::SireCAS::ComplexValues::*what_function_type)(  ) const;            what_function_type what_function_value( &::SireCAS::ComplexValues::what );                        ComplexValues_exposer.def(                 "what"                , what_function_value                , "" );                }        ComplexValues_exposer.staticmethod( "typeName" );        ComplexValues_exposer.def( "__copy__", &__copy__);        ComplexValues_exposer.def( "__deepcopy__", &__copy__);        ComplexValues_exposer.def( "clone", &__copy__);        ComplexValues_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::ComplexValues >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        ComplexValues_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::ComplexValues >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        ComplexValues_exposer.def( "__str__", &pvt_get_name);        ComplexValues_exposer.def( "__repr__", &pvt_get_name);    }}