Пример #1
0
void register_Expression_class(){

    { //::SireCAS::Expression
        typedef bp::class_< SireCAS::Expression > Expression_exposer_t;
        Expression_exposer_t Expression_exposer = Expression_exposer_t( "Expression", bp::init< >() );
        bp::scope Expression_scope( Expression_exposer );
        Expression_exposer.def( bp::init< int >(( bp::arg("constant") )) );
        Expression_exposer.def( bp::init< SireMaths::Rational const & >(( bp::arg("constant") )) );
        Expression_exposer.def( bp::init< double >(( bp::arg("constant") )) );
        Expression_exposer.def( bp::init< SireMaths::Complex const & >(( bp::arg("constant") )) );
        Expression_exposer.def( bp::init< SireCAS::ExpressionBase const & >(( bp::arg("base") )) );
        Expression_exposer.def( bp::init< SireCAS::ExBase const & >(( bp::arg("base") )) );
        Expression_exposer.def( bp::init< SireCAS::Expression const & >(( bp::arg("other") )) );
        { //::SireCAS::Expression::add
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*add_function_type )( ::SireCAS::Expression const & ) const;
            add_function_type add_function_value( &::SireCAS::Expression::add );
            
            Expression_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("ex") ) );
        
        }
        { //::SireCAS::Expression::add
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*add_function_type )( double ) const;
            add_function_type add_function_value( &::SireCAS::Expression::add );
            
            Expression_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("val") ) );
        
        }
        { //::SireCAS::Expression::add
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*add_function_type )( ::SireMaths::Complex const & ) const;
            add_function_type add_function_value( &::SireCAS::Expression::add );
            
            Expression_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("val") ) );
        
        }
        { //::SireCAS::Expression::base
        
            typedef ::SireCAS::ExpressionBase const & ( ::SireCAS::Expression::*base_function_type )(  ) const;
            base_function_type base_function_value( &::SireCAS::Expression::base );
            
            Expression_exposer.def( 
                "base"
                , base_function_value
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireCAS::Expression::children
        
            typedef ::SireCAS::Expressions ( ::SireCAS::Expression::*children_function_type )(  ) const;
            children_function_type children_function_value( &::SireCAS::Expression::children );
            
            Expression_exposer.def( 
                "children"
                , children_function_value );
        
        }
        { //::SireCAS::Expression::conjugate
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*conjugate_function_type )(  ) const;
            conjugate_function_type conjugate_function_value( &::SireCAS::Expression::conjugate );
            
            Expression_exposer.def( 
                "conjugate"
                , conjugate_function_value );
        
        }
        { //::SireCAS::Expression::cubed
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*cubed_function_type )(  ) const;
            cubed_function_type cubed_function_value( &::SireCAS::Expression::cubed );
            
            Expression_exposer.def( 
                "cubed"
                , cubed_function_value );
        
        }
        { //::SireCAS::Expression::diff
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*diff_function_type )( ::SireCAS::Symbol const &,int ) const;
            diff_function_type diff_function_value( &::SireCAS::Expression::diff );
            
            Expression_exposer.def( 
                "diff"
                , diff_function_value
                , ( bp::arg("symbol"), bp::arg("level")=(int)(1) ) );
        
        }
        { //::SireCAS::Expression::differentiate
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*differentiate_function_type )( ::SireCAS::Symbol const &,int ) const;
            differentiate_function_type differentiate_function_value( &::SireCAS::Expression::differentiate );
            
            Expression_exposer.def( 
                "differentiate"
                , differentiate_function_value
                , ( bp::arg("symbol"), bp::arg("level")=(int)(1) ) );
        
        }
        { //::SireCAS::Expression::divide
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*divide_function_type )( ::SireCAS::Expression const & ) const;
            divide_function_type divide_function_value( &::SireCAS::Expression::divide );
            
            Expression_exposer.def( 
                "divide"
                , divide_function_value
                , ( bp::arg("ex") ) );
        
        }
        { //::SireCAS::Expression::divide
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*divide_function_type )( double ) const;
            divide_function_type divide_function_value( &::SireCAS::Expression::divide );
            
            Expression_exposer.def( 
                "divide"
                , divide_function_value
                , ( bp::arg("val") ) );
        
        }
        { //::SireCAS::Expression::divide
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*divide_function_type )( ::SireMaths::Complex const & ) const;
            divide_function_type divide_function_value( &::SireCAS::Expression::divide );
            
            Expression_exposer.def( 
                "divide"
                , divide_function_value
                , ( bp::arg("val") ) );
        
        }
        { //::SireCAS::Expression::evaluate
        
            typedef double ( ::SireCAS::Expression::*evaluate_function_type )( ::SireCAS::Values const & ) const;
            evaluate_function_type evaluate_function_value( &::SireCAS::Expression::evaluate );
            
            Expression_exposer.def( 
                "evaluate"
                , evaluate_function_value
                , ( bp::arg("values") ) );
        
        }
        { //::SireCAS::Expression::evaluate
        
            typedef ::SireMaths::Complex ( ::SireCAS::Expression::*evaluate_function_type )( ::SireCAS::ComplexValues const & ) const;
            evaluate_function_type evaluate_function_value( &::SireCAS::Expression::evaluate );
            
            Expression_exposer.def( 
                "evaluate"
                , evaluate_function_value
                , ( bp::arg("values") ) );
        
        }
        { //::SireCAS::Expression::expand
        
            typedef ::QList< SireCAS::Factor > ( ::SireCAS::Expression::*expand_function_type )( ::SireCAS::Symbol const & ) const;
            expand_function_type expand_function_value( &::SireCAS::Expression::expand );
            
            Expression_exposer.def( 
                "expand"
                , expand_function_value
                , ( bp::arg("symbol") ) );
        
        }
        { //::SireCAS::Expression::factor
        
            typedef double ( ::SireCAS::Expression::*factor_function_type )(  ) const;
            factor_function_type factor_function_value( &::SireCAS::Expression::factor );
            
            Expression_exposer.def( 
                "factor"
                , factor_function_value );
        
        }
        { //::SireCAS::Expression::functions
        
            typedef ::SireCAS::Functions ( ::SireCAS::Expression::*functions_function_type )(  ) const;
            functions_function_type functions_function_value( &::SireCAS::Expression::functions );
            
            Expression_exposer.def( 
                "functions"
                , functions_function_value );
        
        }
        { //::SireCAS::Expression::hash
        
            typedef ::uint ( ::SireCAS::Expression::*hash_function_type )(  ) const;
            hash_function_type hash_function_value( &::SireCAS::Expression::hash );
            
            Expression_exposer.def( 
                "hash"
                , hash_function_value );
        
        }
        { //::SireCAS::Expression::integ
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*integ_function_type )( ::SireCAS::Symbol const & ) const;
            integ_function_type integ_function_value( &::SireCAS::Expression::integ );
            
            Expression_exposer.def( 
                "integ"
                , integ_function_value
                , ( bp::arg("symbol") ) );
        
        }
        { //::SireCAS::Expression::integrate
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*integrate_function_type )( ::SireCAS::Symbol const & ) const;
            integrate_function_type integrate_function_value( &::SireCAS::Expression::integrate );
            
            Expression_exposer.def( 
                "integrate"
                , integrate_function_value
                , ( bp::arg("symbol") ) );
        
        }
        { //::SireCAS::Expression::invert
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*invert_function_type )(  ) const;
            invert_function_type invert_function_value( &::SireCAS::Expression::invert );
            
            Expression_exposer.def( 
                "invert"
                , invert_function_value );
        
        }
        { //::SireCAS::Expression::isComplex
        
            typedef bool ( ::SireCAS::Expression::*isComplex_function_type )(  ) const;
            isComplex_function_type isComplex_function_value( &::SireCAS::Expression::isComplex );
            
            Expression_exposer.def( 
                "isComplex"
                , isComplex_function_value );
        
        }
        { //::SireCAS::Expression::isCompound
        
            typedef bool ( ::SireCAS::Expression::*isCompound_function_type )(  ) const;
            isCompound_function_type isCompound_function_value( &::SireCAS::Expression::isCompound );
            
            Expression_exposer.def( 
                "isCompound"
                , isCompound_function_value );
        
        }
        { //::SireCAS::Expression::isConstant
        
            typedef bool ( ::SireCAS::Expression::*isConstant_function_type )(  ) const;
            isConstant_function_type isConstant_function_value( &::SireCAS::Expression::isConstant );
            
            Expression_exposer.def( 
                "isConstant"
                , isConstant_function_value );
        
        }
        { //::SireCAS::Expression::isFunction
        
            typedef bool ( ::SireCAS::Expression::*isFunction_function_type )( ::SireCAS::Symbol const & ) const;
            isFunction_function_type isFunction_function_value( &::SireCAS::Expression::isFunction );
            
            Expression_exposer.def( 
                "isFunction"
                , isFunction_function_value
                , ( bp::arg("symbol") ) );
        
        }
        { //::SireCAS::Expression::isZero
        
            typedef bool ( ::SireCAS::Expression::*isZero_function_type )(  ) const;
            isZero_function_type isZero_function_value( &::SireCAS::Expression::isZero );
            
            Expression_exposer.def( 
                "isZero"
                , isZero_function_value );
        
        }
        { //::SireCAS::Expression::multiply
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*multiply_function_type )( ::SireCAS::Expression const & ) const;
            multiply_function_type multiply_function_value( &::SireCAS::Expression::multiply );
            
            Expression_exposer.def( 
                "multiply"
                , multiply_function_value
                , ( bp::arg("ex") ) );
        
        }
        { //::SireCAS::Expression::multiply
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*multiply_function_type )( double ) const;
            multiply_function_type multiply_function_value( &::SireCAS::Expression::multiply );
            
            Expression_exposer.def( 
                "multiply"
                , multiply_function_value
                , ( bp::arg("val") ) );
        
        }
        { //::SireCAS::Expression::multiply
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*multiply_function_type )( ::SireMaths::Complex const & ) const;
            multiply_function_type multiply_function_value( &::SireCAS::Expression::multiply );
            
            Expression_exposer.def( 
                "multiply"
                , multiply_function_value
                , ( bp::arg("val") ) );
        
        }
        { //::SireCAS::Expression::negate
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*negate_function_type )(  ) const;
            negate_function_type negate_function_value( &::SireCAS::Expression::negate );
            
            Expression_exposer.def( 
                "negate"
                , negate_function_value );
        
        }
        Expression_exposer.def( bp::self != bp::self );
        { //::SireCAS::Expression::operator()
        
            typedef double ( ::SireCAS::Expression::*__call___function_type )( ::SireCAS::Values const & ) const;
            __call___function_type __call___function_value( &::SireCAS::Expression::operator() );
            
            Expression_exposer.def( 
                "__call__"
                , __call___function_value
                , ( bp::arg("values") ) );
        
        }
        { //::SireCAS::Expression::operator()
        
            typedef ::SireMaths::Complex ( ::SireCAS::Expression::*__call___function_type )( ::SireCAS::ComplexValues const & ) const;
            __call___function_type __call___function_value( &::SireCAS::Expression::operator() );
            
            Expression_exposer.def( 
                "__call__"
                , __call___function_value
                , ( bp::arg("values") ) );
        
        }
        Expression_exposer.def( -bp::self );
        { //::SireCAS::Expression::operator=
        
            typedef ::SireCAS::Expression & ( ::SireCAS::Expression::*assign_function_type )( ::SireCAS::Expression const & ) ;
            assign_function_type assign_function_value( &::SireCAS::Expression::operator= );
            
            Expression_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        Expression_exposer.def( bp::self == bp::self );
        { //::SireCAS::Expression::pow
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( int ) const;
            pow_function_type pow_function_value( &::SireCAS::Expression::pow );
            
            Expression_exposer.def( 
                "pow"
                , pow_function_value
                , ( bp::arg("n") ) );
        
        }
        { //::SireCAS::Expression::pow
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( ::SireMaths::Rational const & ) const;
            pow_function_type pow_function_value( &::SireCAS::Expression::pow );
            
            Expression_exposer.def( 
                "pow"
                , pow_function_value
                , ( bp::arg("n") ) );
        
        }
        { //::SireCAS::Expression::pow
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( double ) const;
            pow_function_type pow_function_value( &::SireCAS::Expression::pow );
            
            Expression_exposer.def( 
                "pow"
                , pow_function_value
                , ( bp::arg("n") ) );
        
        }
        { //::SireCAS::Expression::pow
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( ::SireMaths::Complex const & ) const;
            pow_function_type pow_function_value( &::SireCAS::Expression::pow );
            
            Expression_exposer.def( 
                "pow"
                , pow_function_value
                , ( bp::arg("n") ) );
        
        }
        { //::SireCAS::Expression::pow
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( ::SireCAS::Expression const & ) const;
            pow_function_type pow_function_value( &::SireCAS::Expression::pow );
            
            Expression_exposer.def( 
                "pow"
                , pow_function_value
                , ( bp::arg("n") ) );
        
        }
        { //::SireCAS::Expression::root
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*root_function_type )( int ) const;
            root_function_type root_function_value( &::SireCAS::Expression::root );
            
            Expression_exposer.def( 
                "root"
                , root_function_value
                , ( bp::arg("n") ) );
        
        }
        { //::SireCAS::Expression::series
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*series_function_type )( ::SireCAS::Symbol const &,int ) const;
            series_function_type series_function_value( &::SireCAS::Expression::series );
            
            Expression_exposer.def( 
                "series"
                , series_function_value
                , ( bp::arg("symbol"), bp::arg("order") ) );
        
        }
        { //::SireCAS::Expression::simplify
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*simplify_function_type )( int ) const;
            simplify_function_type simplify_function_value( &::SireCAS::Expression::simplify );
            
            Expression_exposer.def( 
                "simplify"
                , simplify_function_value
                , ( bp::arg("options")=(int)(0) ) );
        
        }
        { //::SireCAS::Expression::squared
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*squared_function_type )(  ) const;
            squared_function_type squared_function_value( &::SireCAS::Expression::squared );
            
            Expression_exposer.def( 
                "squared"
                , squared_function_value );
        
        }
        { //::SireCAS::Expression::substitute
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*substitute_function_type )( ::SireCAS::Identities const & ) const;
            substitute_function_type substitute_function_value( &::SireCAS::Expression::substitute );
            
            Expression_exposer.def( 
                "substitute"
                , substitute_function_value
                , ( bp::arg("identities") ) );
        
        }
        { //::SireCAS::Expression::subtract
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*subtract_function_type )( ::SireCAS::Expression const & ) const;
            subtract_function_type subtract_function_value( &::SireCAS::Expression::subtract );
            
            Expression_exposer.def( 
                "subtract"
                , subtract_function_value
                , ( bp::arg("ex") ) );
        
        }
        { //::SireCAS::Expression::subtract
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*subtract_function_type )( double ) const;
            subtract_function_type subtract_function_value( &::SireCAS::Expression::subtract );
            
            Expression_exposer.def( 
                "subtract"
                , subtract_function_value
                , ( bp::arg("val") ) );
        
        }
        { //::SireCAS::Expression::subtract
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*subtract_function_type )( ::SireMaths::Complex const & ) const;
            subtract_function_type subtract_function_value( &::SireCAS::Expression::subtract );
            
            Expression_exposer.def( 
                "subtract"
                , subtract_function_value
                , ( bp::arg("val") ) );
        
        }
        { //::SireCAS::Expression::symbols
        
            typedef ::SireCAS::Symbols ( ::SireCAS::Expression::*symbols_function_type )(  ) const;
            symbols_function_type symbols_function_value( &::SireCAS::Expression::symbols );
            
            Expression_exposer.def( 
                "symbols"
                , symbols_function_value );
        
        }
        { //::SireCAS::Expression::toString
        
            typedef ::QString ( ::SireCAS::Expression::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireCAS::Expression::toString );
            
            Expression_exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireCAS::Expression::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireCAS::Expression::typeName );
            
            Expression_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireCAS::Expression::what
        
            typedef char const * ( ::SireCAS::Expression::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireCAS::Expression::what );
            
            Expression_exposer.def( 
                "what"
                , what_function_value );
        
        }
        Expression_exposer.staticmethod( "typeName" );
        Expression_exposer.def( bp::self * bp::other< SireMaths::Complex >() );
        Expression_exposer.def( bp::other< SireMaths::Complex >() * bp::self );
        Expression_exposer.def( bp::self * bp::other< double >() );
        Expression_exposer.def( bp::other< double >() * bp::self );
        Expression_exposer.def( bp::self * bp::self );
        Expression_exposer.def( bp::self * bp::other< SireCAS::ExBase >() );
        Expression_exposer.def( bp::other< SireMaths::Complex >() + bp::self );
        Expression_exposer.def( bp::self + bp::other< SireMaths::Complex >() );
        Expression_exposer.def( bp::other< double >() + bp::self );
        Expression_exposer.def( bp::self + bp::other< double >() );
        Expression_exposer.def( bp::self + bp::self );
        Expression_exposer.def( bp::self + bp::other< SireCAS::ExBase >() );
        Expression_exposer.def( bp::other< double >() - bp::self );
        Expression_exposer.def( bp::self - bp::other< double >() );
        Expression_exposer.def( bp::self - bp::self );
        Expression_exposer.def( bp::self - bp::other< SireCAS::ExBase >() );
        Expression_exposer.def( bp::other< SireMaths::Complex >() / bp::self );
        Expression_exposer.def( bp::self / bp::other< SireMaths::Complex >() );
        Expression_exposer.def( bp::other< double >() / bp::self );
        Expression_exposer.def( bp::self / bp::other< double >() );
        Expression_exposer.def( bp::self / bp::self );
        Expression_exposer.def( bp::self / bp::other< SireCAS::ExBase >() );
        Expression_exposer.def( self + self );
        Expression_exposer.def( self - self );
        Expression_exposer.def( self * self );
        Expression_exposer.def( self / self );
        Expression_exposer.def( other<double>() + self );
        Expression_exposer.def( other<double>() - self );
        Expression_exposer.def( other<double>() * self );
        Expression_exposer.def( other<double>() / self );
        Expression_exposer.def( self + other<double>() );
        Expression_exposer.def( self - other<double>() );
        Expression_exposer.def( self * other<double>() );
        Expression_exposer.def( self / other<double>() );
        Expression_exposer.def( other<SireMaths::Complex>() + self );
        Expression_exposer.def( other<SireMaths::Complex>() - self );
        Expression_exposer.def( other<SireMaths::Complex>() * self );
        Expression_exposer.def( other<SireMaths::Complex>() / self );
        Expression_exposer.def( self + other<SireMaths::Complex>() );
        Expression_exposer.def( self - other<SireMaths::Complex>() );
        Expression_exposer.def( self * other<SireMaths::Complex>() );
        Expression_exposer.def( self / other<SireMaths::Complex>() );
        Expression_exposer.def( other<SireCAS::ExBase>() + self );
        Expression_exposer.def( other<SireCAS::ExBase>() - self );
        Expression_exposer.def( other<SireCAS::ExBase>() * self );
        Expression_exposer.def( other<SireCAS::ExBase>() / self );
        Expression_exposer.def( self + other<SireCAS::ExBase>() );
        Expression_exposer.def( self - other<SireCAS::ExBase>() );
        Expression_exposer.def( self * other<SireCAS::ExBase>() );
        Expression_exposer.def( self / other<SireCAS::ExBase>() );
        Expression_exposer.def( "__copy__", &__copy__);
        Expression_exposer.def( "__deepcopy__", &__copy__);
        Expression_exposer.def( "clone", &__copy__);
        Expression_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::Expression >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Expression_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::Expression >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Expression_exposer.def( "__str__", &__str__< ::SireCAS::Expression > );
        Expression_exposer.def( "__repr__", &__str__< ::SireCAS::Expression > );
    }

}
Пример #2
0
void register_PotentialTable_class(){

    { //::SireFF::PotentialTable
        typedef bp::class_< SireFF::PotentialTable > PotentialTable_exposer_t;
        PotentialTable_exposer_t PotentialTable_exposer = PotentialTable_exposer_t( "PotentialTable", "A PotentialTable is a workspace within which all of the potentials\nat the points of atoms in molecules, or the points on a grid\nmay be stored. A PotentialTable is used as storing the potentials\nmay require lots of memory, and continually\ncreating a deleting such large amouts of memory would be inefficient.\nAlso, using a PotentialTable allows for potentials to be accumalated directly,\nrather than requiring intermediate storage space for the\nindividual components.\n\nYou create a potential table to hold all of the potentials at all of\nthe atoms of all of the molecules in a specified MoleculeGroup,\nor at all of the points of a passed Grid.\n\nThe potentials are held in an array that holds the potentials for\nthe molecules in the same order as the molecules appear\nin the molecule group, or in an array that holds the potentials\nin the same order as they appear in the grid.\nThe potential table also comes with an index so you can quickly\nlook up the potential for a specific molecule.\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") );
        bp::scope PotentialTable_scope( PotentialTable_exposer );
        PotentialTable_exposer.def( bp::init< SireMol::MoleculeGroup const & >(( bp::arg("molgroup") ), "Construct the table to hold the potentials at the points of all\nof the atoms in the CutGroups that are viewed in the molecules\nin molgroup") );
        PotentialTable_exposer.def( bp::init< SireVol::Grid const & >(( bp::arg("grid") ), "Construct the table to hold the potentials at all of the points\nin the passed grid") );
        PotentialTable_exposer.def( bp::init< QVector< SireBase::PropPtr< SireVol::Grid > > const & >(( bp::arg("grids") ), "Construct the table to hold the potentials at all of the points\nof all of the passed grids") );
        PotentialTable_exposer.def( bp::init< SireMol::MoleculeGroup const &, SireVol::Grid const & >(( bp::arg("molgroup"), bp::arg("grid") ), "Construct the table to hold the potentials at the points of all\nof the atoms in the CutGroups that are viewed in the molecules\nin molgroup, and all of the grid points in the passed grid") );
        PotentialTable_exposer.def( bp::init< SireMol::MoleculeGroup const &, QVector< SireBase::PropPtr< SireVol::Grid > > const & >(( bp::arg("molgroup"), bp::arg("grids") ), "Construct the table to hold the potentials at the points of all\nof the atoms in the CutGroups that are viewed in the molecules\nin molgroup, and all of the grid points in the passed grids") );
        PotentialTable_exposer.def( bp::init< SireFF::PotentialTable const & >(( bp::arg("other") ), "Copy constructor") );
        { //::SireFF::PotentialTable::add
        
            typedef void ( ::SireFF::PotentialTable::*add_function_type)( ::SireFF::PotentialTable const & ) ;
            add_function_type add_function_value( &::SireFF::PotentialTable::add );
            
            PotentialTable_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("other") )
                , "Add the contents of the table other onto this table. This will only\nadd the potentials for the molecules  grids that are in both tables" );
        
        }
        { //::SireFF::PotentialTable::add
        
            typedef void ( ::SireFF::PotentialTable::*add_function_type)( ::SireUnits::Dimension::MolarEnergy const & ) ;
            add_function_type add_function_value( &::SireFF::PotentialTable::add );
            
            PotentialTable_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("potential") )
                , "Add the potential potential onto all of the atom  grid points in this table" );
        
        }
        { //::SireFF::PotentialTable::assertContainsTableFor
        
            typedef void ( ::SireFF::PotentialTable::*assertContainsTableFor_function_type)( ::SireMol::MolNum ) const;
            assertContainsTableFor_function_type assertContainsTableFor_function_value( &::SireFF::PotentialTable::assertContainsTableFor );
            
            PotentialTable_exposer.def( 
                "assertContainsTableFor"
                , assertContainsTableFor_function_value
                , ( bp::arg("molnum") )
                , "Assert that this contains a table for the molecule with number molnum\nThrow: SireError::unavailable_resource\n" );
        
        }
        { //::SireFF::PotentialTable::assertContainsTableFor
        
            typedef void ( ::SireFF::PotentialTable::*assertContainsTableFor_function_type)( ::SireVol::Grid const & ) const;
            assertContainsTableFor_function_type assertContainsTableFor_function_value( &::SireFF::PotentialTable::assertContainsTableFor );
            
            PotentialTable_exposer.def( 
                "assertContainsTableFor"
                , assertContainsTableFor_function_value
                , ( bp::arg("grid") )
                , "Assert that this contains a table for the passed grid\nThrow: SireError::unavailable_resource\n" );
        
        }
        { //::SireFF::PotentialTable::constGetTable
        
            typedef ::SireFF::MolPotentialTable const & ( ::SireFF::PotentialTable::*constGetTable_function_type)( ::SireMol::MolNum ) const;
            constGetTable_function_type constGetTable_function_value( &::SireFF::PotentialTable::constGetTable );
            
            PotentialTable_exposer.def( 
                "constGetTable"
                , constGetTable_function_value
                , ( bp::arg("molnum") )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "Return the potential table for the passed grid\nThrow: SireError::unavailable_resource\n" );
        
        }
        { //::SireFF::PotentialTable::constGetTable
        
            typedef ::SireFF::GridPotentialTable const & ( ::SireFF::PotentialTable::*constGetTable_function_type)( ::SireVol::Grid const & ) const;
            constGetTable_function_type constGetTable_function_value( &::SireFF::PotentialTable::constGetTable );
            
            PotentialTable_exposer.def( 
                "constGetTable"
                , constGetTable_function_value
                , ( bp::arg("grid") )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "Return the potential table for the passed grid\nThrow: SireError::unavailable_resource\n" );
        
        }
        { //::SireFF::PotentialTable::contains
        
            typedef bool ( ::SireFF::PotentialTable::*contains_function_type)( ::SireMol::MolNum ) const;
            contains_function_type contains_function_value( &::SireFF::PotentialTable::contains );
            
            PotentialTable_exposer.def( 
                "contains"
                , contains_function_value
                , ( bp::arg("molnum") )
                , "Return whether or not this contains a table for the passed grid" );
        
        }
        { //::SireFF::PotentialTable::contains
        
            typedef bool ( ::SireFF::PotentialTable::*contains_function_type)( ::SireVol::Grid const & ) const;
            contains_function_type contains_function_value( &::SireFF::PotentialTable::contains );
            
            PotentialTable_exposer.def( 
                "contains"
                , contains_function_value
                , ( bp::arg("grid") )
                , "Return whether or not this contains a table for the passed grid" );
        
        }
        { //::SireFF::PotentialTable::divide
        
            typedef void ( ::SireFF::PotentialTable::*divide_function_type)( double ) ;
            divide_function_type divide_function_value( &::SireFF::PotentialTable::divide );
            
            PotentialTable_exposer.def( 
                "divide"
                , divide_function_value
                , ( bp::arg("value") )
                , "Divide the potential at all atom and grid points by value" );
        
        }
        { //::SireFF::PotentialTable::getTable
        
            typedef ::SireFF::MolPotentialTable const & ( ::SireFF::PotentialTable::*getTable_function_type)( ::SireMol::MolNum ) const;
            getTable_function_type getTable_function_value( &::SireFF::PotentialTable::getTable );
            
            PotentialTable_exposer.def( 
                "getTable"
                , getTable_function_value
                , ( bp::arg("molnum") )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "Return the potential table for the passed grid\nThrow: SireError::unavailable_resource\n" );
        
        }
        { //::SireFF::PotentialTable::getTable
        
            typedef ::SireFF::GridPotentialTable const & ( ::SireFF::PotentialTable::*getTable_function_type)( ::SireVol::Grid const & ) const;
            getTable_function_type getTable_function_value( &::SireFF::PotentialTable::getTable );
            
            PotentialTable_exposer.def( 
                "getTable"
                , getTable_function_value
                , ( bp::arg("grid") )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "Return the potential table for the passed grid\nThrow: SireError::unavailable_resource\n" );
        
        }
        { //::SireFF::PotentialTable::index
        
            typedef ::QHash< SireMol::MolNum, int > const & ( ::SireFF::PotentialTable::*index_function_type)(  ) const;
            index_function_type index_function_value( &::SireFF::PotentialTable::index );
            
            PotentialTable_exposer.def( 
                "index"
                , index_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireFF::PotentialTable::indexOf
        
            typedef int ( ::SireFF::PotentialTable::*indexOf_function_type)( ::SireMol::MolNum ) const;
            indexOf_function_type indexOf_function_value( &::SireFF::PotentialTable::indexOf );
            
            PotentialTable_exposer.def( 
                "indexOf"
                , indexOf_function_value
                , ( bp::arg("molnum") )
                , "Return the index of the molecule with number molnum in this table\nThrow: SireMol::missing_molecule\n" );
        
        }
        { //::SireFF::PotentialTable::initialiseTable
        
            typedef void ( ::SireFF::PotentialTable::*initialiseTable_function_type)( ::SireMol::MolNum ) ;
            initialiseTable_function_type initialiseTable_function_value( &::SireFF::PotentialTable::initialiseTable );
            
            PotentialTable_exposer.def( 
                "initialiseTable"
                , initialiseTable_function_value
                , ( bp::arg("molnum") )
                , "Initialise the table for the molecule with number molnum" );
        
        }
        { //::SireFF::PotentialTable::initialiseTable
        
            typedef void ( ::SireFF::PotentialTable::*initialiseTable_function_type)( ::SireVol::Grid const & ) ;
            initialiseTable_function_type initialiseTable_function_value( &::SireFF::PotentialTable::initialiseTable );
            
            PotentialTable_exposer.def( 
                "initialiseTable"
                , initialiseTable_function_value
                , ( bp::arg("grid") )
                , "Initialise the table for the grid grid" );
        
        }
        { //::SireFF::PotentialTable::initialiseTables
        
            typedef void ( ::SireFF::PotentialTable::*initialiseTables_function_type)(  ) ;
            initialiseTables_function_type initialiseTables_function_value( &::SireFF::PotentialTable::initialiseTables );
            
            PotentialTable_exposer.def( 
                "initialiseTables"
                , initialiseTables_function_value
                , "Initialise all of the tables to have a zero potential" );
        
        }
        { //::SireFF::PotentialTable::isEmpty
        
            typedef bool ( ::SireFF::PotentialTable::*isEmpty_function_type)(  ) const;
            isEmpty_function_type isEmpty_function_value( &::SireFF::PotentialTable::isEmpty );
            
            PotentialTable_exposer.def( 
                "isEmpty"
                , isEmpty_function_value
                , "Return whether or not this table is empty" );
        
        }
        { //::SireFF::PotentialTable::molNums
        
            typedef ::QList< SireMol::MolNum > ( ::SireFF::PotentialTable::*molNums_function_type)(  ) const;
            molNums_function_type molNums_function_value( &::SireFF::PotentialTable::molNums );
            
            PotentialTable_exposer.def( 
                "molNums"
                , molNums_function_value
                , "" );
        
        }
        { //::SireFF::PotentialTable::multiply
        
            typedef void ( ::SireFF::PotentialTable::*multiply_function_type)( double ) ;
            multiply_function_type multiply_function_value( &::SireFF::PotentialTable::multiply );
            
            PotentialTable_exposer.def( 
                "multiply"
                , multiply_function_value
                , ( bp::arg("value") )
                , "Multiply the potential at all atom and grid points by value" );
        
        }
        { //::SireFF::PotentialTable::nGrids
        
            typedef int ( ::SireFF::PotentialTable::*nGrids_function_type)(  ) const;
            nGrids_function_type nGrids_function_value( &::SireFF::PotentialTable::nGrids );
            
            PotentialTable_exposer.def( 
                "nGrids"
                , nGrids_function_value
                , "" );
        
        }
        { //::SireFF::PotentialTable::nMolecules
        
            typedef int ( ::SireFF::PotentialTable::*nMolecules_function_type)(  ) const;
            nMolecules_function_type nMolecules_function_value( &::SireFF::PotentialTable::nMolecules );
            
            PotentialTable_exposer.def( 
                "nMolecules"
                , nMolecules_function_value
                , "" );
        
        }
        PotentialTable_exposer.def( bp::self != bp::self );
        PotentialTable_exposer.def( bp::self * bp::other< double >() );
        PotentialTable_exposer.def( bp::self + bp::self );
        PotentialTable_exposer.def( bp::self + bp::other< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > >() );
        PotentialTable_exposer.def( bp::self - bp::self );
        PotentialTable_exposer.def( bp::self - bp::other< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > >() );
        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);
    }

}
Пример #3
0
void register_GridPotentialTable_class(){

    { //::SireFF::GridPotentialTable
        typedef bp::class_< SireFF::GridPotentialTable > GridPotentialTable_exposer_t;
        GridPotentialTable_exposer_t GridPotentialTable_exposer = GridPotentialTable_exposer_t( "GridPotentialTable", "A GridPotentialTable contains the potentials at point specified by a grid", bp::init< >("Null constructor") );
        bp::scope GridPotentialTable_scope( GridPotentialTable_exposer );
        GridPotentialTable_exposer.def( bp::init< SireVol::Grid const & >(( bp::arg("grid") ), "Construct to hold the potential at each of the points of the passed grid") );
        GridPotentialTable_exposer.def( bp::init< SireFF::GridPotentialTable const & >(( bp::arg("other") ), "Copy constructor") );
        { //::SireFF::GridPotentialTable::add
        
            typedef void ( ::SireFF::GridPotentialTable::*add_function_type)( int,::SireUnits::Dimension::MolarEnergy const & ) ;
            add_function_type add_function_value( &::SireFF::GridPotentialTable::add );
            
            GridPotentialTable_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("ipoint"), bp::arg("potential") )
                , "Add the potential potential onto the potential for the ipointth grid point\nThrow: SireError::invalid_index\n" );
        
        }
        { //::SireFF::GridPotentialTable::add
        
            typedef void ( ::SireFF::GridPotentialTable::*add_function_type)( ::SireFF::GridPotentialTable const & ) ;
            add_function_type add_function_value( &::SireFF::GridPotentialTable::add );
            
            GridPotentialTable_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("other") )
                , "Add the potential in other onto that for this table - this only\nadds the potential if the two grids are identical" );
        
        }
        { //::SireFF::GridPotentialTable::add
        
            typedef void ( ::SireFF::GridPotentialTable::*add_function_type)( ::SireUnits::Dimension::MolarEnergy const & ) ;
            add_function_type add_function_value( &::SireFF::GridPotentialTable::add );
            
            GridPotentialTable_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("potential") )
                , "Add the potential potential to all of the points in this table" );
        
        }
        { //::SireFF::GridPotentialTable::at
        
            typedef ::SireUnits::Dimension::MolarEnergy const & ( ::SireFF::GridPotentialTable::*at_function_type)( int ) const;
            at_function_type at_function_value( &::SireFF::GridPotentialTable::at );
            
            GridPotentialTable_exposer.def( 
                "at"
                , at_function_value
                , ( bp::arg("i") )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "Return the potential value of the ith grid point\nThrow: SireError::invalid_index\n" );
        
        }
        { //::SireFF::GridPotentialTable::count
        
            typedef int ( ::SireFF::GridPotentialTable::*count_function_type)(  ) const;
            count_function_type count_function_value( &::SireFF::GridPotentialTable::count );
            
            GridPotentialTable_exposer.def( 
                "count"
                , count_function_value
                , "Return the number of grid points (and thus potential values)" );
        
        }
        { //::SireFF::GridPotentialTable::divide
        
            typedef void ( ::SireFF::GridPotentialTable::*divide_function_type)( double ) ;
            divide_function_type divide_function_value( &::SireFF::GridPotentialTable::divide );
            
            GridPotentialTable_exposer.def( 
                "divide"
                , divide_function_value
                , ( bp::arg("value") )
                , "Divide the potential at all of the points in this table by value" );
        
        }
        { //::SireFF::GridPotentialTable::grid
        
            typedef ::SireVol::Grid const & ( ::SireFF::GridPotentialTable::*grid_function_type)(  ) const;
            grid_function_type grid_function_value( &::SireFF::GridPotentialTable::grid );
            
            GridPotentialTable_exposer.def( 
                "grid"
                , grid_function_value
                , bp::return_value_policy<bp::clone_const_reference>()
                , "Return the grid that contains the points at which the potential is\nevaluated - the order of points in the grid is the same as the order\nof potential values in this table" );
        
        }
        { //::SireFF::GridPotentialTable::initialise
        
            typedef void ( ::SireFF::GridPotentialTable::*initialise_function_type)(  ) ;
            initialise_function_type initialise_function_value( &::SireFF::GridPotentialTable::initialise );
            
            GridPotentialTable_exposer.def( 
                "initialise"
                , initialise_function_value
                , "Initialise the potential at each grid point to equal 0" );
        
        }
        { //::SireFF::GridPotentialTable::multiply
        
            typedef void ( ::SireFF::GridPotentialTable::*multiply_function_type)( double ) ;
            multiply_function_type multiply_function_value( &::SireFF::GridPotentialTable::multiply );
            
            GridPotentialTable_exposer.def( 
                "multiply"
                , multiply_function_value
                , ( bp::arg("value") )
                , "Multiply the potential at all of the points in this table by value" );
        
        }
        { //::SireFF::GridPotentialTable::nPoints
        
            typedef int ( ::SireFF::GridPotentialTable::*nPoints_function_type)(  ) const;
            nPoints_function_type nPoints_function_value( &::SireFF::GridPotentialTable::nPoints );
            
            GridPotentialTable_exposer.def( 
                "nPoints"
                , nPoints_function_value
                , "Return the number of grid points (and thus potential values)" );
        
        }
        GridPotentialTable_exposer.def( bp::self != bp::self );
        GridPotentialTable_exposer.def( bp::self * bp::other< double >() );
        GridPotentialTable_exposer.def( bp::self + bp::self );
        GridPotentialTable_exposer.def( bp::self + bp::other< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > >() );
        GridPotentialTable_exposer.def( bp::self - bp::self );
        GridPotentialTable_exposer.def( bp::self - bp::other< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > >() );
        GridPotentialTable_exposer.def( -bp::self );
        GridPotentialTable_exposer.def( bp::self / bp::other< double >() );
        { //::SireFF::GridPotentialTable::operator=
        
            typedef ::SireFF::GridPotentialTable & ( ::SireFF::GridPotentialTable::*assign_function_type)( ::SireFF::GridPotentialTable const & ) ;
            assign_function_type assign_function_value( &::SireFF::GridPotentialTable::operator= );
            
            GridPotentialTable_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >()
                , "" );
        
        }
        { //::SireFF::GridPotentialTable::operator=
        
            typedef ::SireFF::GridPotentialTable & ( ::SireFF::GridPotentialTable::*assign_function_type)( ::SireUnits::Dimension::MolarEnergy const & ) ;
            assign_function_type assign_function_value( &::SireFF::GridPotentialTable::operator= );
            
            GridPotentialTable_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("potential") )
                , bp::return_self< >()
                , "" );
        
        }
        GridPotentialTable_exposer.def( bp::self == bp::self );
        { //::SireFF::GridPotentialTable::operator[]
        
            typedef ::SireUnits::Dimension::MolarEnergy & ( ::SireFF::GridPotentialTable::*__getitem___function_type)( int ) ;
            __getitem___function_type __getitem___function_value( &::SireFF::GridPotentialTable::operator[] );
            
            GridPotentialTable_exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("i") )
                , bp::return_internal_reference< >()
                , "" );
        
        }
        { //::SireFF::GridPotentialTable::operator[]
        
            typedef ::SireUnits::Dimension::MolarEnergy const & ( ::SireFF::GridPotentialTable::*__getitem___function_type)( int ) const;
            __getitem___function_type __getitem___function_value( &::SireFF::GridPotentialTable::operator[] );
            
            GridPotentialTable_exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("i") )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireFF::GridPotentialTable::setAll
        
            typedef void ( ::SireFF::GridPotentialTable::*setAll_function_type)( ::SireUnits::Dimension::MolarEnergy const & ) ;
            setAll_function_type setAll_function_value( &::SireFF::GridPotentialTable::setAll );
            
            GridPotentialTable_exposer.def( 
                "setAll"
                , setAll_function_value
                , ( bp::arg("potential") )
                , "Set the potential at all of the points in this table equal to potential" );
        
        }
        { //::SireFF::GridPotentialTable::subtract
        
            typedef void ( ::SireFF::GridPotentialTable::*subtract_function_type)( int,::SireUnits::Dimension::MolarEnergy const & ) ;
            subtract_function_type subtract_function_value( &::SireFF::GridPotentialTable::subtract );
            
            GridPotentialTable_exposer.def( 
                "subtract"
                , subtract_function_value
                , ( bp::arg("ipoint"), bp::arg("potential") )
                , "Subtract the potential potential from the potential for the ipointth grid point\nThrow: SireError::invalid_index\n" );
        
        }
        { //::SireFF::GridPotentialTable::subtract
        
            typedef void ( ::SireFF::GridPotentialTable::*subtract_function_type)( ::SireFF::GridPotentialTable const & ) ;
            subtract_function_type subtract_function_value( &::SireFF::GridPotentialTable::subtract );
            
            GridPotentialTable_exposer.def( 
                "subtract"
                , subtract_function_value
                , ( bp::arg("other") )
                , "Subtract the potential in other from that for this table - this only\nsubtracts the potential if the two grids are identical" );
        
        }
        { //::SireFF::GridPotentialTable::subtract
        
            typedef void ( ::SireFF::GridPotentialTable::*subtract_function_type)( ::SireUnits::Dimension::MolarEnergy const & ) ;
            subtract_function_type subtract_function_value( &::SireFF::GridPotentialTable::subtract );
            
            GridPotentialTable_exposer.def( 
                "subtract"
                , subtract_function_value
                , ( bp::arg("potential") )
                , "Subtract the potential potential from all of the points in this table" );
        
        }
        { //::SireFF::GridPotentialTable::toVector
        
            typedef ::QVector< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > > ( ::SireFF::GridPotentialTable::*toVector_function_type)(  ) const;
            toVector_function_type toVector_function_value( &::SireFF::GridPotentialTable::toVector );
            
            GridPotentialTable_exposer.def( 
                "toVector"
                , toVector_function_value
                , "Return the array of potential values - the order is the same\nas the order of points in the grid" );
        
        }
        { //::SireFF::GridPotentialTable::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireFF::GridPotentialTable::typeName );
            
            GridPotentialTable_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        GridPotentialTable_exposer.staticmethod( "typeName" );
        GridPotentialTable_exposer.def( "__copy__", &__copy__);
        GridPotentialTable_exposer.def( "__deepcopy__", &__copy__);
        GridPotentialTable_exposer.def( "clone", &__copy__);
        GridPotentialTable_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireFF::GridPotentialTable >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        GridPotentialTable_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireFF::GridPotentialTable >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        GridPotentialTable_exposer.def( "__str__", &pvt_get_name);
        GridPotentialTable_exposer.def( "__repr__", &pvt_get_name);
        GridPotentialTable_exposer.def( "__len__", &__len_count< ::SireFF::GridPotentialTable > );
    }

}
Пример #4
0
void register_MolPotentialTable_class(){

    { //::SireFF::MolPotentialTable
        typedef bp::class_< SireFF::MolPotentialTable > MolPotentialTable_exposer_t;
        MolPotentialTable_exposer_t MolPotentialTable_exposer = MolPotentialTable_exposer_t( "MolPotentialTable", bp::init< >() );
        bp::scope MolPotentialTable_scope( MolPotentialTable_exposer );
        MolPotentialTable_exposer.def( bp::init< SireMol::MoleculeView const & >(( bp::arg("molview") )) );
        MolPotentialTable_exposer.def( bp::init< SireFF::MolPotentialTable const & >(( bp::arg("other") )) );
        { //::SireFF::MolPotentialTable::add
        
            typedef bool ( ::SireFF::MolPotentialTable::*add_function_type )( ::SireMol::CGAtomIdx const &,::SireUnits::Dimension::MolarEnergy const & ) ;
            add_function_type add_function_value( &::SireFF::MolPotentialTable::add );
            
            MolPotentialTable_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("cgatomidx"), bp::arg("potential") ) );
        
        }
        { //::SireFF::MolPotentialTable::add
        
            typedef bool ( ::SireFF::MolPotentialTable::*add_function_type )( ::SireMol::AtomSelection const &,::SireUnits::Dimension::MolarEnergy const & ) ;
            add_function_type add_function_value( &::SireFF::MolPotentialTable::add );
            
            MolPotentialTable_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("selected_atoms"), bp::arg("potential") ) );
        
        }
        { //::SireFF::MolPotentialTable::add
        
            typedef void ( ::SireFF::MolPotentialTable::*add_function_type )( ::SireFF::MolPotentialTable const & ) ;
            add_function_type add_function_value( &::SireFF::MolPotentialTable::add );
            
            MolPotentialTable_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("other") ) );
        
        }
        { //::SireFF::MolPotentialTable::add
        
            typedef void ( ::SireFF::MolPotentialTable::*add_function_type )( ::SireUnits::Dimension::MolarEnergy const & ) ;
            add_function_type add_function_value( &::SireFF::MolPotentialTable::add );
            
            MolPotentialTable_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("potential") ) );
        
        }
        { //::SireFF::MolPotentialTable::divide
        
            typedef void ( ::SireFF::MolPotentialTable::*divide_function_type )( double ) ;
            divide_function_type divide_function_value( &::SireFF::MolPotentialTable::divide );
            
            MolPotentialTable_exposer.def( 
                "divide"
                , divide_function_value
                , ( bp::arg("value") ) );
        
        }
        { //::SireFF::MolPotentialTable::initialise
        
            typedef void ( ::SireFF::MolPotentialTable::*initialise_function_type )(  ) ;
            initialise_function_type initialise_function_value( &::SireFF::MolPotentialTable::initialise );
            
            MolPotentialTable_exposer.def( 
                "initialise"
                , initialise_function_value );
        
        }
        { //::SireFF::MolPotentialTable::map
        
            typedef int ( ::SireFF::MolPotentialTable::*map_function_type )( ::SireMol::CGIdx ) const;
            map_function_type map_function_value( &::SireFF::MolPotentialTable::map );
            
            MolPotentialTable_exposer.def( 
                "map"
                , map_function_value
                , ( bp::arg("cgidx") ) );
        
        }
        { //::SireFF::MolPotentialTable::molNum
        
            typedef ::SireMol::MolNum ( ::SireFF::MolPotentialTable::*molNum_function_type )(  ) const;
            molNum_function_type molNum_function_value( &::SireFF::MolPotentialTable::molNum );
            
            MolPotentialTable_exposer.def( 
                "molNum"
                , molNum_function_value );
        
        }
        { //::SireFF::MolPotentialTable::molUID
        
            typedef ::QUuid const & ( ::SireFF::MolPotentialTable::*molUID_function_type )(  ) const;
            molUID_function_type molUID_function_value( &::SireFF::MolPotentialTable::molUID );
            
            MolPotentialTable_exposer.def( 
                "molUID"
                , molUID_function_value
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireFF::MolPotentialTable::multiply
        
            typedef void ( ::SireFF::MolPotentialTable::*multiply_function_type )( double ) ;
            multiply_function_type multiply_function_value( &::SireFF::MolPotentialTable::multiply );
            
            MolPotentialTable_exposer.def( 
                "multiply"
                , multiply_function_value
                , ( bp::arg("value") ) );
        
        }
        { //::SireFF::MolPotentialTable::nCutGroups
        
            typedef int ( ::SireFF::MolPotentialTable::*nCutGroups_function_type )(  ) const;
            nCutGroups_function_type nCutGroups_function_value( &::SireFF::MolPotentialTable::nCutGroups );
            
            MolPotentialTable_exposer.def( 
                "nCutGroups"
                , nCutGroups_function_value );
        
        }
        { //::SireFF::MolPotentialTable::nSelectedCutGroups
        
            typedef int ( ::SireFF::MolPotentialTable::*nSelectedCutGroups_function_type )(  ) const;
            nSelectedCutGroups_function_type nSelectedCutGroups_function_value( &::SireFF::MolPotentialTable::nSelectedCutGroups );
            
            MolPotentialTable_exposer.def( 
                "nSelectedCutGroups"
                , nSelectedCutGroups_function_value );
        
        }
        MolPotentialTable_exposer.def( bp::self != bp::self );
        MolPotentialTable_exposer.def( bp::self * bp::other< double >() );
        MolPotentialTable_exposer.def( bp::self + bp::self );
        MolPotentialTable_exposer.def( bp::self + bp::other< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > >() );
        MolPotentialTable_exposer.def( bp::self - bp::self );
        MolPotentialTable_exposer.def( bp::self - bp::other< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > >() );
        MolPotentialTable_exposer.def( -bp::self );
        MolPotentialTable_exposer.def( bp::self / bp::other< double >() );
        { //::SireFF::MolPotentialTable::operator=
        
            typedef ::SireFF::MolPotentialTable & ( ::SireFF::MolPotentialTable::*assign_function_type )( ::SireFF::MolPotentialTable const & ) ;
            assign_function_type assign_function_value( &::SireFF::MolPotentialTable::operator= );
            
            MolPotentialTable_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        { //::SireFF::MolPotentialTable::operator=
        
            typedef ::SireFF::MolPotentialTable & ( ::SireFF::MolPotentialTable::*assign_function_type )( ::SireUnits::Dimension::MolarEnergy const & ) ;
            assign_function_type assign_function_value( &::SireFF::MolPotentialTable::operator= );
            
            MolPotentialTable_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("potential") )
                , bp::return_self< >() );
        
        }
        MolPotentialTable_exposer.def( bp::self == bp::self );
        { //::SireFF::MolPotentialTable::selected
        
            typedef bool ( ::SireFF::MolPotentialTable::*selected_function_type )( ::SireMol::CGIdx ) const;
            selected_function_type selected_function_value( &::SireFF::MolPotentialTable::selected );
            
            MolPotentialTable_exposer.def( 
                "selected"
                , selected_function_value
                , ( bp::arg("cgidx") ) );
        
        }
        { //::SireFF::MolPotentialTable::selectedAll
        
            typedef bool ( ::SireFF::MolPotentialTable::*selectedAll_function_type )(  ) const;
            selectedAll_function_type selectedAll_function_value( &::SireFF::MolPotentialTable::selectedAll );
            
            MolPotentialTable_exposer.def( 
                "selectedAll"
                , selectedAll_function_value );
        
        }
        { //::SireFF::MolPotentialTable::setAll
        
            typedef void ( ::SireFF::MolPotentialTable::*setAll_function_type )( ::SireUnits::Dimension::MolarEnergy const & ) ;
            setAll_function_type setAll_function_value( &::SireFF::MolPotentialTable::setAll );
            
            MolPotentialTable_exposer.def( 
                "setAll"
                , setAll_function_value
                , ( bp::arg("potential") ) );
        
        }
        { //::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 > );
    }

}
Пример #5
0
void register_AtomFloatProperty_class(){

    { //::SireMol::AtomProperty< double >
        typedef bp::class_< SireMol::AtomProperty< double >, bp::bases< SireMol::AtomProp, SireMol::MolViewProperty, SireBase::Property > > AtomFloatProperty_exposer_t;
        AtomFloatProperty_exposer_t AtomFloatProperty_exposer = AtomFloatProperty_exposer_t( "AtomFloatProperty", "", bp::init< >("") );
        bp::scope AtomFloatProperty_scope( AtomFloatProperty_exposer );
        AtomFloatProperty_exposer.def( bp::init< SireMol::MoleculeInfoData const & >(( bp::arg("molinfo") ), "") );
        AtomFloatProperty_exposer.def( bp::init< SireMol::MoleculeInfoData const &, double const & >(( bp::arg("molinfo"), bp::arg("default_value") ), "") );
        AtomFloatProperty_exposer.def( bp::init< double const & >(( bp::arg("value") ), "") );
        AtomFloatProperty_exposer.def( bp::init< SireBase::PackedArray2D< double > const & >(( bp::arg("values") ), "") );
        AtomFloatProperty_exposer.def( bp::init< SireMol::AtomProperty< double > const & >(( bp::arg("other") ), "") );
        { //::SireMol::AtomProperty< double >::array
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef ::SireBase::PackedArray2D< double > const & ( ::SireMol::AtomProperty< double >::*array_function_type)(  ) const;
            array_function_type array_function_value( &::SireMol::AtomProperty< double >::array );
            
            AtomFloatProperty_exposer.def( 
                "array"
                , array_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::assertCanConvert
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< double >::*assertCanConvert_function_type)( ::QVariant const & ) const;
            assertCanConvert_function_type assertCanConvert_function_value( &::SireMol::AtomProperty< double >::assertCanConvert );
            
            AtomFloatProperty_exposer.def( 
                "assertCanConvert"
                , assertCanConvert_function_value
                , ( bp::arg("value") )
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::assignFrom
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< double >::*assignFrom_function_type)( ::SireMol::AtomProperty< QVariant > const & ) ;
            assignFrom_function_type assignFrom_function_value( &::SireMol::AtomProperty< double >::assignFrom );
            
            AtomFloatProperty_exposer.def( 
                "assignFrom"
                , assignFrom_function_value
                , ( bp::arg("values") )
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::at
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef ::SireBase::PackedArray2D< double >::Array const & ( ::SireMol::AtomProperty< double >::*at_function_type)( ::SireMol::CGIdx ) const;
            at_function_type at_function_value( &::SireMol::AtomProperty< double >::at );
            
            AtomFloatProperty_exposer.def( 
                "at"
                , at_function_value
                , ( bp::arg("cgidx") )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::at
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef double const & ( ::SireMol::AtomProperty< double >::*at_function_type)( ::SireMol::CGAtomIdx const & ) const;
            at_function_type at_function_value( &::SireMol::AtomProperty< double >::at );
            
            AtomFloatProperty_exposer.def( 
                "at"
                , at_function_value
                , ( bp::arg("cgatomidx") )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::canConvert
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef bool ( ::SireMol::AtomProperty< double >::*canConvert_function_type)( ::QVariant const & ) const;
            canConvert_function_type canConvert_function_value( &::SireMol::AtomProperty< double >::canConvert );
            
            AtomFloatProperty_exposer.def( 
                "canConvert"
                , canConvert_function_value
                , ( bp::arg("value") )
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::copyFrom
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< double >::*copyFrom_function_type)( ::QVector< double > const & ) ;
            copyFrom_function_type copyFrom_function_value( &::SireMol::AtomProperty< double >::copyFrom );
            
            AtomFloatProperty_exposer.def( 
                "copyFrom"
                , copyFrom_function_value
                , ( bp::arg("values") )
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::copyFrom
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< double >::*copyFrom_function_type)( ::QVector< double > const &,::SireMol::AtomSelection const & ) ;
            copyFrom_function_type copyFrom_function_value( &::SireMol::AtomProperty< double >::copyFrom );
            
            AtomFloatProperty_exposer.def( 
                "copyFrom"
                , copyFrom_function_value
                , ( bp::arg("values"), bp::arg("selection") )
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::count
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef int ( ::SireMol::AtomProperty< double >::*count_function_type)(  ) const;
            count_function_type count_function_value( &::SireMol::AtomProperty< double >::count );
            
            AtomFloatProperty_exposer.def( 
                "count"
                , count_function_value
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::divide
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef ::SireBase::PropertyPtr ( ::SireMol::AtomProperty< double >::*divide_function_type)( ::QVector< SireMol::AtomSelection > const & ) const;
            divide_function_type divide_function_value( &::SireMol::AtomProperty< double >::divide );
            
            AtomFloatProperty_exposer.def( 
                "divide"
                , divide_function_value
                , ( bp::arg("beads") )
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::divideByResidue
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef ::SireBase::PropertyPtr ( ::SireMol::AtomProperty< double >::*divideByResidue_function_type)( ::SireMol::MoleculeInfoData const & ) const;
            divideByResidue_function_type divideByResidue_function_value( &::SireMol::AtomProperty< double >::divideByResidue );
            
            AtomFloatProperty_exposer.def( 
                "divideByResidue"
                , divideByResidue_function_value
                , ( bp::arg("molinfo") )
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::fromVariant
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef ::SireMol::AtomProperty< double > ( *fromVariant_function_type )( ::SireMol::AtomProperty< QVariant > const & );
            fromVariant_function_type fromVariant_function_value( &::SireMol::AtomProperty< double >::fromVariant );
            
            AtomFloatProperty_exposer.def( 
                "fromVariant"
                , fromVariant_function_value
                , ( bp::arg("variant") )
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::get
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef ::SireBase::PackedArray2D< double >::Array const & ( ::SireMol::AtomProperty< double >::*get_function_type)( ::SireMol::CGIdx ) const;
            get_function_type get_function_value( &::SireMol::AtomProperty< double >::get );
            
            AtomFloatProperty_exposer.def( 
                "get"
                , get_function_value
                , ( bp::arg("cgidx") )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::get
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef double const & ( ::SireMol::AtomProperty< double >::*get_function_type)( ::SireMol::CGAtomIdx const & ) const;
            get_function_type get_function_value( &::SireMol::AtomProperty< double >::get );
            
            AtomFloatProperty_exposer.def( 
                "get"
                , get_function_value
                , ( bp::arg("cgatomidx") )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::isCompatibleWith
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef bool ( ::SireMol::AtomProperty< double >::*isCompatibleWith_function_type)( ::SireMol::MoleculeInfoData const & ) const;
            isCompatibleWith_function_type isCompatibleWith_function_value( &::SireMol::AtomProperty< double >::isCompatibleWith );
            
            AtomFloatProperty_exposer.def( 
                "isCompatibleWith"
                , isCompatibleWith_function_value
                , ( bp::arg("molinfo") )
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::isCompatibleWith
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef bool ( ::SireMol::AtomProperty< double >::*isCompatibleWith_function_type)( ::SireMol::MoleculeInfo const & ) const;
            isCompatibleWith_function_type isCompatibleWith_function_value( &::SireMol::AtomProperty< double >::isCompatibleWith );
            
            AtomFloatProperty_exposer.def( 
                "isCompatibleWith"
                , isCompatibleWith_function_value
                , ( bp::arg("molinfo") )
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::isEmpty
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef bool ( ::SireMol::AtomProperty< double >::*isEmpty_function_type)(  ) const;
            isEmpty_function_type isEmpty_function_value( &::SireMol::AtomProperty< double >::isEmpty );
            
            AtomFloatProperty_exposer.def( 
                "isEmpty"
                , isEmpty_function_value
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::matchToSelection
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef ::SireMol::AtomProperty< double > ( ::SireMol::AtomProperty< double >::*matchToSelection_function_type)( ::SireMol::AtomSelection const & ) const;
            matchToSelection_function_type matchToSelection_function_value( &::SireMol::AtomProperty< double >::matchToSelection );
            
            AtomFloatProperty_exposer.def( 
                "matchToSelection"
                , matchToSelection_function_value
                , ( bp::arg("selection") )
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::merge
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef ::SireBase::PropertyPtr ( ::SireMol::AtomProperty< double >::*merge_function_type)( ::SireMol::MoleculeInfoData const & ) const;
            merge_function_type merge_function_value( &::SireMol::AtomProperty< double >::merge );
            
            AtomFloatProperty_exposer.def( 
                "merge"
                , merge_function_value
                , ( bp::arg("molinfo") )
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::nAtoms
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef int ( ::SireMol::AtomProperty< double >::*nAtoms_function_type)(  ) const;
            nAtoms_function_type nAtoms_function_value( &::SireMol::AtomProperty< double >::nAtoms );
            
            AtomFloatProperty_exposer.def( 
                "nAtoms"
                , nAtoms_function_value
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::nAtoms
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef int ( ::SireMol::AtomProperty< double >::*nAtoms_function_type)( ::SireMol::CGIdx ) const;
            nAtoms_function_type nAtoms_function_value( &::SireMol::AtomProperty< double >::nAtoms );
            
            AtomFloatProperty_exposer.def( 
                "nAtoms"
                , nAtoms_function_value
                , ( bp::arg("cgidx") )
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::nCutGroups
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef int ( ::SireMol::AtomProperty< double >::*nCutGroups_function_type)(  ) const;
            nCutGroups_function_type nCutGroups_function_value( &::SireMol::AtomProperty< double >::nCutGroups );
            
            AtomFloatProperty_exposer.def( 
                "nCutGroups"
                , nCutGroups_function_value
                , "" );
        
        }
        AtomFloatProperty_exposer.def( bp::self != bp::self );
        { //::SireMol::AtomProperty< double >::operator=
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef ::SireMol::AtomProperty< double > & ( ::SireMol::AtomProperty< double >::*assign_function_type)( ::SireMol::AtomProperty< double > const & ) ;
            assign_function_type assign_function_value( &::SireMol::AtomProperty< double >::operator= );
            
            AtomFloatProperty_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >()
                , "" );
        
        }
        AtomFloatProperty_exposer.def( bp::self == bp::self );
        { //::SireMol::AtomProperty< double >::operator[]
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef ::SireBase::PackedArray2D< double >::Array const & ( ::SireMol::AtomProperty< double >::*__getitem___function_type)( ::SireMol::CGIdx ) const;
            __getitem___function_type __getitem___function_value( &::SireMol::AtomProperty< double >::operator[] );
            
            AtomFloatProperty_exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("cgidx") )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::operator[]
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef double const & ( ::SireMol::AtomProperty< double >::*__getitem___function_type)( ::SireMol::CGAtomIdx const & ) const;
            __getitem___function_type __getitem___function_value( &::SireMol::AtomProperty< double >::operator[] );
            
            AtomFloatProperty_exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("cgatomidx") )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::set
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef ::SireMol::AtomProperty< double > & ( ::SireMol::AtomProperty< double >::*set_function_type)( ::SireMol::CGAtomIdx const &,double const & ) ;
            set_function_type set_function_value( &::SireMol::AtomProperty< double >::set );
            
            AtomFloatProperty_exposer.def( 
                "set"
                , set_function_value
                , ( bp::arg("cgatomidx"), bp::arg("value") )
                , bp::return_self< >()
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::set
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef ::SireMol::AtomProperty< double > & ( ::SireMol::AtomProperty< double >::*set_function_type)( ::SireMol::CGIdx,::QVector< double > const & ) ;
            set_function_type set_function_value( &::SireMol::AtomProperty< double >::set );
            
            AtomFloatProperty_exposer.def( 
                "set"
                , set_function_value
                , ( bp::arg("cgidx"), bp::arg("values") )
                , bp::return_self< >()
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::size
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef int ( ::SireMol::AtomProperty< double >::*size_function_type)(  ) const;
            size_function_type size_function_value( &::SireMol::AtomProperty< double >::size );
            
            AtomFloatProperty_exposer.def( 
                "size"
                , size_function_value
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::toString
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef ::QString ( ::SireMol::AtomProperty< double >::*toString_function_type)(  ) const;
            toString_function_type toString_function_value( &::SireMol::AtomProperty< double >::toString );
            
            AtomFloatProperty_exposer.def( 
                "toString"
                , toString_function_value
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::toVariant
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef ::SireMol::AtomProperty< QVariant > ( ::SireMol::AtomProperty< double >::*toVariant_function_type)(  ) const;
            toVariant_function_type toVariant_function_value( &::SireMol::AtomProperty< double >::toVariant );
            
            AtomFloatProperty_exposer.def( 
                "toVariant"
                , toVariant_function_value
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::toVector
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef ::QVector< double > ( ::SireMol::AtomProperty< double >::*toVector_function_type)(  ) const;
            toVector_function_type toVector_function_value( &::SireMol::AtomProperty< double >::toVector );
            
            AtomFloatProperty_exposer.def( 
                "toVector"
                , toVector_function_value
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::toVector
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef ::QVector< double > ( ::SireMol::AtomProperty< double >::*toVector_function_type)( ::SireMol::AtomSelection const & ) const;
            toVector_function_type toVector_function_value( &::SireMol::AtomProperty< double >::toVector );
            
            AtomFloatProperty_exposer.def( 
                "toVector"
                , toVector_function_value
                , ( bp::arg("selection") )
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::typeName
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMol::AtomProperty< double >::typeName );
            
            AtomFloatProperty_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        AtomFloatProperty_exposer.staticmethod( "fromVariant" );
        AtomFloatProperty_exposer.staticmethod( "typeName" );
        AtomFloatProperty_exposer.def( "__copy__", &__copy__);
        AtomFloatProperty_exposer.def( "__deepcopy__", &__copy__);
        AtomFloatProperty_exposer.def( "clone", &__copy__);
        AtomFloatProperty_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::AtomProperty<double> >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        AtomFloatProperty_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::AtomProperty<double> >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        AtomFloatProperty_exposer.def( "__str__", &__str__< ::SireMol::AtomProperty<double> > );
        AtomFloatProperty_exposer.def( "__repr__", &__str__< ::SireMol::AtomProperty<double> > );
        AtomFloatProperty_exposer.def( "__len__", &__len_size< ::SireMol::AtomProperty<double> > );
    }

}
Пример #6
0
void register_GridPotentialTable_class(){

    { //::SireFF::GridPotentialTable
        typedef bp::class_< SireFF::GridPotentialTable > GridPotentialTable_exposer_t;
        GridPotentialTable_exposer_t GridPotentialTable_exposer = GridPotentialTable_exposer_t( "GridPotentialTable", bp::init< >() );
        bp::scope GridPotentialTable_scope( GridPotentialTable_exposer );
        GridPotentialTable_exposer.def( bp::init< SireVol::Grid const & >(( bp::arg("grid") )) );
        GridPotentialTable_exposer.def( bp::init< SireFF::GridPotentialTable const & >(( bp::arg("other") )) );
        { //::SireFF::GridPotentialTable::add
        
            typedef void ( ::SireFF::GridPotentialTable::*add_function_type )( int,::SireUnits::Dimension::MolarEnergy const & ) ;
            add_function_type add_function_value( &::SireFF::GridPotentialTable::add );
            
            GridPotentialTable_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("ipoint"), bp::arg("potential") ) );
        
        }
        { //::SireFF::GridPotentialTable::add
        
            typedef void ( ::SireFF::GridPotentialTable::*add_function_type )( ::SireFF::GridPotentialTable const & ) ;
            add_function_type add_function_value( &::SireFF::GridPotentialTable::add );
            
            GridPotentialTable_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("other") ) );
        
        }
        { //::SireFF::GridPotentialTable::add
        
            typedef void ( ::SireFF::GridPotentialTable::*add_function_type )( ::SireUnits::Dimension::MolarEnergy const & ) ;
            add_function_type add_function_value( &::SireFF::GridPotentialTable::add );
            
            GridPotentialTable_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("potential") ) );
        
        }
        { //::SireFF::GridPotentialTable::at
        
            typedef ::SireUnits::Dimension::MolarEnergy const & ( ::SireFF::GridPotentialTable::*at_function_type )( int ) const;
            at_function_type at_function_value( &::SireFF::GridPotentialTable::at );
            
            GridPotentialTable_exposer.def( 
                "at"
                , at_function_value
                , ( bp::arg("i") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireFF::GridPotentialTable::count
        
            typedef int ( ::SireFF::GridPotentialTable::*count_function_type )(  ) const;
            count_function_type count_function_value( &::SireFF::GridPotentialTable::count );
            
            GridPotentialTable_exposer.def( 
                "count"
                , count_function_value );
        
        }
        { //::SireFF::GridPotentialTable::divide
        
            typedef void ( ::SireFF::GridPotentialTable::*divide_function_type )( double ) ;
            divide_function_type divide_function_value( &::SireFF::GridPotentialTable::divide );
            
            GridPotentialTable_exposer.def( 
                "divide"
                , divide_function_value
                , ( bp::arg("value") ) );
        
        }
        { //::SireFF::GridPotentialTable::grid
        
            typedef ::SireVol::Grid const & ( ::SireFF::GridPotentialTable::*grid_function_type )(  ) const;
            grid_function_type grid_function_value( &::SireFF::GridPotentialTable::grid );
            
            GridPotentialTable_exposer.def( 
                "grid"
                , grid_function_value
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::SireFF::GridPotentialTable::initialise
        
            typedef void ( ::SireFF::GridPotentialTable::*initialise_function_type )(  ) ;
            initialise_function_type initialise_function_value( &::SireFF::GridPotentialTable::initialise );
            
            GridPotentialTable_exposer.def( 
                "initialise"
                , initialise_function_value );
        
        }
        { //::SireFF::GridPotentialTable::multiply
        
            typedef void ( ::SireFF::GridPotentialTable::*multiply_function_type )( double ) ;
            multiply_function_type multiply_function_value( &::SireFF::GridPotentialTable::multiply );
            
            GridPotentialTable_exposer.def( 
                "multiply"
                , multiply_function_value
                , ( bp::arg("value") ) );
        
        }
        { //::SireFF::GridPotentialTable::nPoints
        
            typedef int ( ::SireFF::GridPotentialTable::*nPoints_function_type )(  ) const;
            nPoints_function_type nPoints_function_value( &::SireFF::GridPotentialTable::nPoints );
            
            GridPotentialTable_exposer.def( 
                "nPoints"
                , nPoints_function_value );
        
        }
        GridPotentialTable_exposer.def( bp::self != bp::self );
        GridPotentialTable_exposer.def( bp::self * bp::other< double >() );
        GridPotentialTable_exposer.def( bp::self + bp::self );
        GridPotentialTable_exposer.def( bp::self + bp::other< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > >() );
        GridPotentialTable_exposer.def( bp::self - bp::self );
        GridPotentialTable_exposer.def( bp::self - bp::other< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > >() );
        GridPotentialTable_exposer.def( -bp::self );
        GridPotentialTable_exposer.def( bp::self / bp::other< double >() );
        { //::SireFF::GridPotentialTable::operator=
        
            typedef ::SireFF::GridPotentialTable & ( ::SireFF::GridPotentialTable::*assign_function_type )( ::SireFF::GridPotentialTable const & ) ;
            assign_function_type assign_function_value( &::SireFF::GridPotentialTable::operator= );
            
            GridPotentialTable_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        { //::SireFF::GridPotentialTable::operator=
        
            typedef ::SireFF::GridPotentialTable & ( ::SireFF::GridPotentialTable::*assign_function_type )( ::SireUnits::Dimension::MolarEnergy const & ) ;
            assign_function_type assign_function_value( &::SireFF::GridPotentialTable::operator= );
            
            GridPotentialTable_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("potential") )
                , bp::return_self< >() );
        
        }
        GridPotentialTable_exposer.def( bp::self == bp::self );
        { //::SireFF::GridPotentialTable::operator[]
        
            typedef ::SireUnits::Dimension::MolarEnergy & ( ::SireFF::GridPotentialTable::*__getitem___function_type )( int ) ;
            __getitem___function_type __getitem___function_value( &::SireFF::GridPotentialTable::operator[] );
            
            GridPotentialTable_exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("i") )
                , bp::return_internal_reference< >() );
        
        }
        { //::SireFF::GridPotentialTable::operator[]
        
            typedef ::SireUnits::Dimension::MolarEnergy const & ( ::SireFF::GridPotentialTable::*__getitem___function_type )( int ) const;
            __getitem___function_type __getitem___function_value( &::SireFF::GridPotentialTable::operator[] );
            
            GridPotentialTable_exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("i") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireFF::GridPotentialTable::setAll
        
            typedef void ( ::SireFF::GridPotentialTable::*setAll_function_type )( ::SireUnits::Dimension::MolarEnergy const & ) ;
            setAll_function_type setAll_function_value( &::SireFF::GridPotentialTable::setAll );
            
            GridPotentialTable_exposer.def( 
                "setAll"
                , setAll_function_value
                , ( bp::arg("potential") ) );
        
        }
        { //::SireFF::GridPotentialTable::subtract
        
            typedef void ( ::SireFF::GridPotentialTable::*subtract_function_type )( int,::SireUnits::Dimension::MolarEnergy const & ) ;
            subtract_function_type subtract_function_value( &::SireFF::GridPotentialTable::subtract );
            
            GridPotentialTable_exposer.def( 
                "subtract"
                , subtract_function_value
                , ( bp::arg("ipoint"), bp::arg("potential") ) );
        
        }
        { //::SireFF::GridPotentialTable::subtract
        
            typedef void ( ::SireFF::GridPotentialTable::*subtract_function_type )( ::SireFF::GridPotentialTable const & ) ;
            subtract_function_type subtract_function_value( &::SireFF::GridPotentialTable::subtract );
            
            GridPotentialTable_exposer.def( 
                "subtract"
                , subtract_function_value
                , ( bp::arg("other") ) );
        
        }
        { //::SireFF::GridPotentialTable::subtract
        
            typedef void ( ::SireFF::GridPotentialTable::*subtract_function_type )( ::SireUnits::Dimension::MolarEnergy const & ) ;
            subtract_function_type subtract_function_value( &::SireFF::GridPotentialTable::subtract );
            
            GridPotentialTable_exposer.def( 
                "subtract"
                , subtract_function_value
                , ( bp::arg("potential") ) );
        
        }
        { //::SireFF::GridPotentialTable::toVector
        
            typedef ::QVector< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > > ( ::SireFF::GridPotentialTable::*toVector_function_type )(  ) const;
            toVector_function_type toVector_function_value( &::SireFF::GridPotentialTable::toVector );
            
            GridPotentialTable_exposer.def( 
                "toVector"
                , toVector_function_value );
        
        }
        { //::SireFF::GridPotentialTable::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireFF::GridPotentialTable::typeName );
            
            GridPotentialTable_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        GridPotentialTable_exposer.staticmethod( "typeName" );
        GridPotentialTable_exposer.def( "__copy__", &__copy__);
        GridPotentialTable_exposer.def( "__deepcopy__", &__copy__);
        GridPotentialTable_exposer.def( "clone", &__copy__);
        GridPotentialTable_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireFF::GridPotentialTable >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        GridPotentialTable_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireFF::GridPotentialTable >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        GridPotentialTable_exposer.def( "__str__", &pvt_get_name);
        GridPotentialTable_exposer.def( "__repr__", &pvt_get_name);
        GridPotentialTable_exposer.def( "__len__", &__len_count< ::SireFF::GridPotentialTable > );
    }

}
Пример #7
0
void register_ForceTable_class(){

    { //::SireFF::ForceTable
        typedef bp::class_< SireFF::ForceTable > ForceTable_exposer_t;
        ForceTable_exposer_t ForceTable_exposer = ForceTable_exposer_t( "ForceTable", bp::init< >() );
        bp::scope ForceTable_scope( ForceTable_exposer );
        ForceTable_exposer.def( bp::init< SireMol::MoleculeGroup const & >(( bp::arg("molgroup") )) );
        ForceTable_exposer.def( bp::init< SireFF::ForceTable const & >(( bp::arg("other") )) );
        { //::SireFF::ForceTable::add
        
            typedef void ( ::SireFF::ForceTable::*add_function_type )( ::SireFF::ForceTable const & ) ;
            add_function_type add_function_value( &::SireFF::ForceTable::add );
            
            ForceTable_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("other") ) );
        
        }
        { //::SireFF::ForceTable::add
        
            typedef void ( ::SireFF::ForceTable::*add_function_type )( ::SireMaths::Vector const & ) ;
            add_function_type add_function_value( &::SireFF::ForceTable::add );
            
            ForceTable_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("force") ) );
        
        }
        { //::SireFF::ForceTable::assertContainsTableFor
        
            typedef void ( ::SireFF::ForceTable::*assertContainsTableFor_function_type )( ::SireMol::MolNum ) const;
            assertContainsTableFor_function_type assertContainsTableFor_function_value( &::SireFF::ForceTable::assertContainsTableFor );
            
            ForceTable_exposer.def( 
                "assertContainsTableFor"
                , assertContainsTableFor_function_value
                , ( bp::arg("molnum") ) );
        
        }
        { //::SireFF::ForceTable::constGetTable
        
            typedef ::SireFF::MolForceTable const & ( ::SireFF::ForceTable::*constGetTable_function_type )( ::SireMol::MolNum ) const;
            constGetTable_function_type constGetTable_function_value( &::SireFF::ForceTable::constGetTable );
            
            ForceTable_exposer.def( 
                "constGetTable"
                , constGetTable_function_value
                , ( bp::arg("molnum") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireFF::ForceTable::containsTable
        
            typedef bool ( ::SireFF::ForceTable::*containsTable_function_type )( ::SireMol::MolNum ) const;
            containsTable_function_type containsTable_function_value( &::SireFF::ForceTable::containsTable );
            
            ForceTable_exposer.def( 
                "containsTable"
                , containsTable_function_value
                , ( bp::arg("molnum") ) );
        
        }
        { //::SireFF::ForceTable::count
        
            typedef int ( ::SireFF::ForceTable::*count_function_type )(  ) const;
            count_function_type count_function_value( &::SireFF::ForceTable::count );
            
            ForceTable_exposer.def( 
                "count"
                , count_function_value );
        
        }
        { //::SireFF::ForceTable::divide
        
            typedef void ( ::SireFF::ForceTable::*divide_function_type )( double ) ;
            divide_function_type divide_function_value( &::SireFF::ForceTable::divide );
            
            ForceTable_exposer.def( 
                "divide"
                , divide_function_value
                , ( bp::arg("value") ) );
        
        }
        { //::SireFF::ForceTable::getTable
        
            typedef ::SireFF::MolForceTable const & ( ::SireFF::ForceTable::*getTable_function_type )( ::SireMol::MolNum ) const;
            getTable_function_type getTable_function_value( &::SireFF::ForceTable::getTable );
            
            ForceTable_exposer.def( 
                "getTable"
                , getTable_function_value
                , ( bp::arg("molnum") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireFF::ForceTable::index
        
            typedef ::QHash< SireMol::MolNum, int > const & ( ::SireFF::ForceTable::*index_function_type )(  ) const;
            index_function_type index_function_value( &::SireFF::ForceTable::index );
            
            ForceTable_exposer.def( 
                "index"
                , index_function_value
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireFF::ForceTable::indexOf
        
            typedef int ( ::SireFF::ForceTable::*indexOf_function_type )( ::SireMol::MolNum ) const;
            indexOf_function_type indexOf_function_value( &::SireFF::ForceTable::indexOf );
            
            ForceTable_exposer.def( 
                "indexOf"
                , indexOf_function_value
                , ( bp::arg("molnum") ) );
        
        }
        { //::SireFF::ForceTable::initialiseTable
        
            typedef void ( ::SireFF::ForceTable::*initialiseTable_function_type )( ::SireMol::MolNum ) ;
            initialiseTable_function_type initialiseTable_function_value( &::SireFF::ForceTable::initialiseTable );
            
            ForceTable_exposer.def( 
                "initialiseTable"
                , initialiseTable_function_value
                , ( bp::arg("molnum") ) );
        
        }
        { //::SireFF::ForceTable::initialiseTables
        
            typedef void ( ::SireFF::ForceTable::*initialiseTables_function_type )(  ) ;
            initialiseTables_function_type initialiseTables_function_value( &::SireFF::ForceTable::initialiseTables );
            
            ForceTable_exposer.def( 
                "initialiseTables"
                , initialiseTables_function_value );
        
        }
        { //::SireFF::ForceTable::molNums
        
            typedef ::QList< SireMol::MolNum > ( ::SireFF::ForceTable::*molNums_function_type )(  ) const;
            molNums_function_type molNums_function_value( &::SireFF::ForceTable::molNums );
            
            ForceTable_exposer.def( 
                "molNums"
                , molNums_function_value );
        
        }
        { //::SireFF::ForceTable::multiply
        
            typedef void ( ::SireFF::ForceTable::*multiply_function_type )( double ) ;
            multiply_function_type multiply_function_value( &::SireFF::ForceTable::multiply );
            
            ForceTable_exposer.def( 
                "multiply"
                , multiply_function_value
                , ( bp::arg("value") ) );
        
        }
        ForceTable_exposer.def( bp::self != bp::self );
        ForceTable_exposer.def( bp::self * bp::other< double >() );
        ForceTable_exposer.def( bp::self + bp::self );
        ForceTable_exposer.def( bp::self + bp::other< SireMaths::Vector >() );
        ForceTable_exposer.def( bp::self - bp::self );
        ForceTable_exposer.def( bp::self - bp::other< SireMaths::Vector >() );
        ForceTable_exposer.def( -bp::self );
        ForceTable_exposer.def( bp::self / bp::other< double >() );
        { //::SireFF::ForceTable::operator=
        
            typedef ::SireFF::ForceTable & ( ::SireFF::ForceTable::*assign_function_type )( ::SireFF::ForceTable const & ) ;
            assign_function_type assign_function_value( &::SireFF::ForceTable::operator= );
            
            ForceTable_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        { //::SireFF::ForceTable::operator=
        
            typedef ::SireFF::ForceTable & ( ::SireFF::ForceTable::*assign_function_type )( ::SireMaths::Vector const & ) ;
            assign_function_type assign_function_value( &::SireFF::ForceTable::operator= );
            
            ForceTable_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("force") )
                , bp::return_self< >() );
        
        }
        ForceTable_exposer.def( bp::self == bp::self );
        { //::SireFF::ForceTable::setAll
        
            typedef void ( ::SireFF::ForceTable::*setAll_function_type )( ::SireMaths::Vector const & ) ;
            setAll_function_type setAll_function_value( &::SireFF::ForceTable::setAll );
            
            ForceTable_exposer.def( 
                "setAll"
                , setAll_function_value
                , ( bp::arg("force") ) );
        
        }
        { //::SireFF::ForceTable::subtract
        
            typedef void ( ::SireFF::ForceTable::*subtract_function_type )( ::SireFF::ForceTable const & ) ;
            subtract_function_type subtract_function_value( &::SireFF::ForceTable::subtract );
            
            ForceTable_exposer.def( 
                "subtract"
                , subtract_function_value
                , ( bp::arg("other") ) );
        
        }
        { //::SireFF::ForceTable::subtract
        
            typedef void ( ::SireFF::ForceTable::*subtract_function_type )( ::SireMaths::Vector const & ) ;
            subtract_function_type subtract_function_value( &::SireFF::ForceTable::subtract );
            
            ForceTable_exposer.def( 
                "subtract"
                , subtract_function_value
                , ( bp::arg("force") ) );
        
        }
        { //::SireFF::ForceTable::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireFF::ForceTable::typeName );
            
            ForceTable_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireFF::ForceTable::what
        
            typedef char const * ( ::SireFF::ForceTable::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireFF::ForceTable::what );
            
            ForceTable_exposer.def( 
                "what"
                , what_function_value );
        
        }
        ForceTable_exposer.staticmethod( "typeName" );
        ForceTable_exposer.def( "__copy__", &__copy__);
        ForceTable_exposer.def( "__deepcopy__", &__copy__);
        ForceTable_exposer.def( "clone", &__copy__);
        ForceTable_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireFF::ForceTable >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        ForceTable_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireFF::ForceTable >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        ForceTable_exposer.def( "__str__", &pvt_get_name);
        ForceTable_exposer.def( "__repr__", &pvt_get_name);
        ForceTable_exposer.def( "__len__", &__len_count< ::SireFF::ForceTable > );
    }

}
Пример #8
0
void register_AtomCoords_class(){

    { //::SireMol::AtomProperty< SireMaths::Vector >
        typedef bp::class_< SireMol::AtomProperty< SireMaths::Vector >, bp::bases< SireMol::AtomProp, SireMol::MolViewProperty, SireBase::Property > > AtomCoords_exposer_t;
        AtomCoords_exposer_t AtomCoords_exposer = AtomCoords_exposer_t( "AtomCoords", bp::init< >() );
        bp::scope AtomCoords_scope( AtomCoords_exposer );
        AtomCoords_exposer.def( bp::init< SireMol::MoleculeInfoData const & >(( bp::arg("molinfo") )) );
        AtomCoords_exposer.def( bp::init< SireVol::CoordGroup const & >(( bp::arg("cgroup") )) );
        AtomCoords_exposer.def( bp::init< SireVol::CoordGroupArray const & >(( bp::arg("cgroups") )) );
        AtomCoords_exposer.def( bp::init< SireMol::AtomProperty< SireMaths::Vector > const & >(( bp::arg("other") )) );
        { //::SireMol::AtomProperty< SireMaths::Vector >::array
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::SireVol::CoordGroupArray const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*array_function_type )(  ) const;
            array_function_type array_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::array );
            
            AtomCoords_exposer.def( 
                "array"
                , array_function_value
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::assertCanConvert
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*assertCanConvert_function_type )( ::QVariant const & ) const;
            assertCanConvert_function_type assertCanConvert_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::assertCanConvert );
            
            AtomCoords_exposer.def( 
                "assertCanConvert"
                , assertCanConvert_function_value
                , ( bp::arg("value") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::assignFrom
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*assignFrom_function_type )( ::SireMol::AtomProperty< QVariant > const & ) ;
            assignFrom_function_type assignFrom_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::assignFrom );
            
            AtomCoords_exposer.def( 
                "assignFrom"
                , assignFrom_function_value
                , ( bp::arg("values") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::at
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::SireVol::CoordGroup const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*at_function_type )( ::SireMol::CGIdx ) const;
            at_function_type at_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::at );
            
            AtomCoords_exposer.def( 
                "at"
                , at_function_value
                , ( bp::arg("cgidx") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::at
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::SireMaths::Vector const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*at_function_type )( ::SireMol::CGAtomIdx const & ) const;
            at_function_type at_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::at );
            
            AtomCoords_exposer.def( 
                "at"
                , at_function_value
                , ( bp::arg("cgatomidx") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::canConvert
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef bool ( ::SireMol::AtomProperty< SireMaths::Vector >::*canConvert_function_type )( ::QVariant const & ) const;
            canConvert_function_type canConvert_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::canConvert );
            
            AtomCoords_exposer.def( 
                "canConvert"
                , canConvert_function_value
                , ( bp::arg("value") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::changeFrame
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*changeFrame_function_type )( ::SireMaths::AxisSet const &,::SireMaths::AxisSet const & ) ;
            changeFrame_function_type changeFrame_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::changeFrame );
            
            AtomCoords_exposer.def( 
                "changeFrame"
                , changeFrame_function_value
                , ( bp::arg("from_frame"), bp::arg("to_frame") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::changeFrame
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*changeFrame_function_type )( ::SireMol::CGIdx,::SireMaths::AxisSet const &,::SireMaths::AxisSet const & ) ;
            changeFrame_function_type changeFrame_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::changeFrame );
            
            AtomCoords_exposer.def( 
                "changeFrame"
                , changeFrame_function_value
                , ( bp::arg("cgidx"), bp::arg("from_frame"), bp::arg("to_frame") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::copyFrom
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*copyFrom_function_type )( ::QVector< SireMaths::Vector > const & ) ;
            copyFrom_function_type copyFrom_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::copyFrom );
            
            AtomCoords_exposer.def( 
                "copyFrom"
                , copyFrom_function_value
                , ( bp::arg("values") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::copyFrom
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*copyFrom_function_type )( ::QVector< SireMaths::Vector > const &,::SireMol::AtomSelection const & ) ;
            copyFrom_function_type copyFrom_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::copyFrom );
            
            AtomCoords_exposer.def( 
                "copyFrom"
                , copyFrom_function_value
                , ( bp::arg("values"), bp::arg("selection") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::count
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef int ( ::SireMol::AtomProperty< SireMaths::Vector >::*count_function_type )(  ) const;
            count_function_type count_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::count );
            
            AtomCoords_exposer.def( 
                "count"
                , count_function_value );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::divide
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::SireBase::PropertyPtr ( ::SireMol::AtomProperty< SireMaths::Vector >::*divide_function_type )( ::QVector< SireMol::AtomSelection > const & ) const;
            divide_function_type divide_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::divide );
            
            AtomCoords_exposer.def( 
                "divide"
                , divide_function_value
                , ( bp::arg("beads") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::divideByResidue
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::SireBase::PropertyPtr ( ::SireMol::AtomProperty< SireMaths::Vector >::*divideByResidue_function_type )( ::SireMol::MoleculeInfoData const & ) const;
            divideByResidue_function_type divideByResidue_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::divideByResidue );
            
            AtomCoords_exposer.def( 
                "divideByResidue"
                , divideByResidue_function_value
                , ( bp::arg("molinfo") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::fromVariant
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::SireMol::AtomProperty< SireMaths::Vector > ( *fromVariant_function_type )( ::SireMol::AtomProperty< QVariant > const & );
            fromVariant_function_type fromVariant_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::fromVariant );
            
            AtomCoords_exposer.def( 
                "fromVariant"
                , fromVariant_function_value
                , ( bp::arg("variant") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::get
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::SireVol::CoordGroup const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*get_function_type )( ::SireMol::CGIdx ) const;
            get_function_type get_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::get );
            
            AtomCoords_exposer.def( 
                "get"
                , get_function_value
                , ( bp::arg("cgidx") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::get
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::SireMaths::Vector const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*get_function_type )( ::SireMol::CGAtomIdx const & ) const;
            get_function_type get_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::get );
            
            AtomCoords_exposer.def( 
                "get"
                , get_function_value
                , ( bp::arg("cgatomidx") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::isCompatibleWith
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef bool ( ::SireMol::AtomProperty< SireMaths::Vector >::*isCompatibleWith_function_type )( ::SireMol::MoleculeInfoData const & ) const;
            isCompatibleWith_function_type isCompatibleWith_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::isCompatibleWith );
            
            AtomCoords_exposer.def( 
                "isCompatibleWith"
                , isCompatibleWith_function_value
                , ( bp::arg("molinfo") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::mapInto
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*mapInto_function_type )( ::SireMaths::AxisSet const & ) ;
            mapInto_function_type mapInto_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::mapInto );
            
            AtomCoords_exposer.def( 
                "mapInto"
                , mapInto_function_value
                , ( bp::arg("axes") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::mapInto
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*mapInto_function_type )( ::SireMol::CGIdx,::SireMaths::AxisSet const & ) ;
            mapInto_function_type mapInto_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::mapInto );
            
            AtomCoords_exposer.def( 
                "mapInto"
                , mapInto_function_value
                , ( bp::arg("cgidx"), bp::arg("axes") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::merge
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::SireBase::PropertyPtr ( ::SireMol::AtomProperty< SireMaths::Vector >::*merge_function_type )( ::SireMol::MoleculeInfoData const & ) const;
            merge_function_type merge_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::merge );
            
            AtomCoords_exposer.def( 
                "merge"
                , merge_function_value
                , ( bp::arg("molinfo") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::nAtoms
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef int ( ::SireMol::AtomProperty< SireMaths::Vector >::*nAtoms_function_type )(  ) const;
            nAtoms_function_type nAtoms_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::nAtoms );
            
            AtomCoords_exposer.def( 
                "nAtoms"
                , nAtoms_function_value );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::nAtoms
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef int ( ::SireMol::AtomProperty< SireMaths::Vector >::*nAtoms_function_type )( ::SireMol::CGIdx ) const;
            nAtoms_function_type nAtoms_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::nAtoms );
            
            AtomCoords_exposer.def( 
                "nAtoms"
                , nAtoms_function_value
                , ( bp::arg("cgidx") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::nCutGroups
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef int ( ::SireMol::AtomProperty< SireMaths::Vector >::*nCutGroups_function_type )(  ) const;
            nCutGroups_function_type nCutGroups_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::nCutGroups );
            
            AtomCoords_exposer.def( 
                "nCutGroups"
                , nCutGroups_function_value );
        
        }
        AtomCoords_exposer.def( bp::self != bp::self );
        { //::SireMol::AtomProperty< SireMaths::Vector >::operator=
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::SireMol::AtomProperty< SireMaths::Vector > & ( ::SireMol::AtomProperty< SireMaths::Vector >::*assign_function_type )( ::SireMol::AtomProperty< SireMaths::Vector > const & ) ;
            assign_function_type assign_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::operator= );
            
            AtomCoords_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        AtomCoords_exposer.def( bp::self == bp::self );
        { //::SireMol::AtomProperty< SireMaths::Vector >::operator[]
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::SireVol::CoordGroup const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*__getitem___function_type )( ::SireMol::CGIdx ) const;
            __getitem___function_type __getitem___function_value( &::SireMol::AtomProperty< SireMaths::Vector >::operator[] );
            
            AtomCoords_exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("cgidx") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::operator[]
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::SireMaths::Vector const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*__getitem___function_type )( ::SireMol::CGAtomIdx const & ) const;
            __getitem___function_type __getitem___function_value( &::SireMol::AtomProperty< SireMaths::Vector >::operator[] );
            
            AtomCoords_exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("cgatomidx") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::rotate
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*rotate_function_type )( ::SireMaths::Quaternion const &,::SireMaths::Vector const & ) ;
            rotate_function_type rotate_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::rotate );
            
            AtomCoords_exposer.def( 
                "rotate"
                , rotate_function_value
                , ( bp::arg("quat"), bp::arg("point") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::rotate
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*rotate_function_type )( ::SireMaths::Matrix const &,::SireMaths::Vector const & ) ;
            rotate_function_type rotate_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::rotate );
            
            AtomCoords_exposer.def( 
                "rotate"
                , rotate_function_value
                , ( bp::arg("rotmat"), bp::arg("point") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::rotate
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*rotate_function_type )( ::SireMol::CGIdx,::SireMaths::Quaternion const &,::SireMaths::Vector const & ) ;
            rotate_function_type rotate_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::rotate );
            
            AtomCoords_exposer.def( 
                "rotate"
                , rotate_function_value
                , ( bp::arg("cgidx"), bp::arg("quat"), bp::arg("point") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::rotate
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*rotate_function_type )( ::SireMol::CGIdx,::SireMaths::Matrix const &,::SireMaths::Vector const & ) ;
            rotate_function_type rotate_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::rotate );
            
            AtomCoords_exposer.def( 
                "rotate"
                , rotate_function_value
                , ( bp::arg("cgidx"), bp::arg("rotmat"), bp::arg("point") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::set
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::SireMol::AtomProperty< SireMaths::Vector > & ( ::SireMol::AtomProperty< SireMaths::Vector >::*set_function_type )( ::SireMol::CGAtomIdx const &,::SireMaths::Vector const & ) ;
            set_function_type set_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::set );
            
            AtomCoords_exposer.def( 
                "set"
                , set_function_value
                , ( bp::arg("cgatomidx"), bp::arg("value") )
                , bp::return_self< >() );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::set
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::SireMol::AtomProperty< SireMaths::Vector > & ( ::SireMol::AtomProperty< SireMaths::Vector >::*set_function_type )( ::SireMol::CGIdx,::QVector< SireMaths::Vector > const & ) ;
            set_function_type set_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::set );
            
            AtomCoords_exposer.def( 
                "set"
                , set_function_value
                , ( bp::arg("cgidx"), bp::arg("values") )
                , bp::return_self< >() );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::set
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::SireMol::AtomProperty< SireMaths::Vector > & ( ::SireMol::AtomProperty< SireMaths::Vector >::*set_function_type )( ::SireMol::CGIdx,::SireVol::CoordGroup const & ) ;
            set_function_type set_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::set );
            
            AtomCoords_exposer.def( 
                "set"
                , set_function_value
                , ( bp::arg("cgidx"), bp::arg("cgroup") )
                , bp::return_self< >() );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::size
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef int ( ::SireMol::AtomProperty< SireMaths::Vector >::*size_function_type )(  ) const;
            size_function_type size_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::size );
            
            AtomCoords_exposer.def( 
                "size"
                , size_function_value );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::toVariant
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::SireMol::AtomProperty< QVariant > ( ::SireMol::AtomProperty< SireMaths::Vector >::*toVariant_function_type )(  ) const;
            toVariant_function_type toVariant_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::toVariant );
            
            AtomCoords_exposer.def( 
                "toVariant"
                , toVariant_function_value );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::toVector
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::QVector< SireMaths::Vector > ( ::SireMol::AtomProperty< SireMaths::Vector >::*toVector_function_type )(  ) const;
            toVector_function_type toVector_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::toVector );
            
            AtomCoords_exposer.def( 
                "toVector"
                , toVector_function_value );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::toVector
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::QVector< SireMaths::Vector > ( ::SireMol::AtomProperty< SireMaths::Vector >::*toVector_function_type )( ::SireMol::AtomSelection const & ) const;
            toVector_function_type toVector_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::toVector );
            
            AtomCoords_exposer.def( 
                "toVector"
                , toVector_function_value
                , ( bp::arg("selection") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::transform
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*transform_function_type )( ::SireMaths::Transform const & ) ;
            transform_function_type transform_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::transform );
            
            AtomCoords_exposer.def( 
                "transform"
                , transform_function_value
                , ( bp::arg("t") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::transform
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*transform_function_type )( ::SireMol::CGIdx,::SireMaths::Transform const & ) ;
            transform_function_type transform_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::transform );
            
            AtomCoords_exposer.def( 
                "transform"
                , transform_function_value
                , ( bp::arg("cgidx"), bp::arg("t") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::translate
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*translate_function_type )( ::SireMaths::Vector const & ) ;
            translate_function_type translate_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::translate );
            
            AtomCoords_exposer.def( 
                "translate"
                , translate_function_value
                , ( bp::arg("delta") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::translate
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*translate_function_type )( ::SireMol::CGIdx,::SireMaths::Vector const & ) ;
            translate_function_type translate_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::translate );
            
            AtomCoords_exposer.def( 
                "translate"
                , translate_function_value
                , ( bp::arg("cgidx"), bp::arg("delta") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::typeName
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::typeName );
            
            AtomCoords_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        AtomCoords_exposer.staticmethod( "fromVariant" );
        AtomCoords_exposer.staticmethod( "typeName" );
        AtomCoords_exposer.def( "__copy__", &__copy__);
        AtomCoords_exposer.def( "__deepcopy__", &__copy__);
        AtomCoords_exposer.def( "clone", &__copy__);
        AtomCoords_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::AtomProperty<SireMaths::Vector> >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        AtomCoords_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::AtomProperty<SireMaths::Vector> >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        AtomCoords_exposer.def( "__str__", &__str__< ::SireMol::AtomProperty<SireMaths::Vector> > );
        AtomCoords_exposer.def( "__repr__", &__str__< ::SireMol::AtomProperty<SireMaths::Vector> > );
        AtomCoords_exposer.def( "__len__", &__len_size< ::SireMol::AtomProperty<SireMaths::Vector> > );
    }

}