void register_DoubleFunc_class(){
{ //::SireCAS::DoubleFunc
typedef bp::class_< SireCAS::DoubleFunc, bp::bases< SireCAS::ExBase >, boost::noncopyable > DoubleFunc_exposer_t;
DoubleFunc_exposer_t DoubleFunc_exposer = DoubleFunc_exposer_t( "DoubleFunc", "Base class of all double-expression functions ( e.g. f(x(), y()) )\n\nAuthor: Christopher Woods\n", bp::no_init );
bp::scope DoubleFunc_scope( DoubleFunc_exposer );
{ //::SireCAS::DoubleFunc::children
typedef ::SireCAS::Expressions ( ::SireCAS::DoubleFunc::*children_function_type)( ) const;
children_function_type children_function_value( &::SireCAS::DoubleFunc::children );
DoubleFunc_exposer.def(
"children"
, children_function_value
, "Return the child expression of this function" );
}
{ //::SireCAS::DoubleFunc::conjugate
typedef ::SireCAS::Expression ( ::SireCAS::DoubleFunc::*conjugate_function_type)( ) const;
conjugate_function_type conjugate_function_value( &::SireCAS::DoubleFunc::conjugate );
DoubleFunc_exposer.def(
"conjugate"
, conjugate_function_value
, "Return the conjugate of this function" );
}
{ //::SireCAS::DoubleFunc::differentiate
typedef ::SireCAS::Expression ( ::SireCAS::DoubleFunc::*differentiate_function_type)( ::SireCAS::Symbol const & ) const;
differentiate_function_type differentiate_function_value( &::SireCAS::DoubleFunc::differentiate );
DoubleFunc_exposer.def(
"differentiate"
, differentiate_function_value
, ( bp::arg("symbol") )
, "Return the differential of this function with respect to symbol" );
}
{ //::SireCAS::DoubleFunc::expand
typedef ::QList< SireCAS::Factor > ( ::SireCAS::DoubleFunc::*expand_function_type)( ::SireCAS::Symbol const & ) const;
expand_function_type expand_function_value( &::SireCAS::DoubleFunc::expand );
DoubleFunc_exposer.def(
"expand"
, expand_function_value
, ( bp::arg("symbol") )
, "" );
}
{ //::SireCAS::DoubleFunc::functions
typedef ::SireCAS::Functions ( ::SireCAS::DoubleFunc::*functions_function_type)( ) const;
functions_function_type functions_function_value( &::SireCAS::DoubleFunc::functions );
DoubleFunc_exposer.def(
"functions"
, functions_function_value
, "Return the functions used in this function" );
}
{ //::SireCAS::DoubleFunc::hash
typedef ::uint ( ::SireCAS::DoubleFunc::*hash_function_type)( ) const;
hash_function_type hash_function_value( &::SireCAS::DoubleFunc::hash );
DoubleFunc_exposer.def(
"hash"
, hash_function_value
, "Return a has for the function" );
}
{ //::SireCAS::DoubleFunc::integrate
typedef ::SireCAS::Expression ( ::SireCAS::DoubleFunc::*integrate_function_type)( ::SireCAS::Symbol const & ) const;
integrate_function_type integrate_function_value( &::SireCAS::DoubleFunc::integrate );
DoubleFunc_exposer.def(
"integrate"
, integrate_function_value
, ( bp::arg("symbol") )
, "Return the integral of this function with respect to symbol" );
}
{ //::SireCAS::DoubleFunc::isComplex
typedef bool ( ::SireCAS::DoubleFunc::*isComplex_function_type)( ) const;
isComplex_function_type isComplex_function_value( &::SireCAS::DoubleFunc::isComplex );
DoubleFunc_exposer.def(
"isComplex"
, isComplex_function_value
, "Return whether this is complex" );
}
{ //::SireCAS::DoubleFunc::isCompound
typedef bool ( ::SireCAS::DoubleFunc::*isCompound_function_type)( ) const;
isCompound_function_type isCompound_function_value( &::SireCAS::DoubleFunc::isCompound );
DoubleFunc_exposer.def(
"isCompound"
, isCompound_function_value
, "A function is not compound" );
}
{ //::SireCAS::DoubleFunc::isConstant
typedef bool ( ::SireCAS::DoubleFunc::*isConstant_function_type)( ) const;
isConstant_function_type isConstant_function_value( &::SireCAS::DoubleFunc::isConstant );
DoubleFunc_exposer.def(
"isConstant"
, isConstant_function_value
, "Return whether or not this is constant" );
}
{ //::SireCAS::DoubleFunc::isFunction
typedef bool ( ::SireCAS::DoubleFunc::*isFunction_function_type)( ::SireCAS::Symbol const & ) const;
isFunction_function_type isFunction_function_value( &::SireCAS::DoubleFunc::isFunction );
DoubleFunc_exposer.def(
"isFunction"
, isFunction_function_value
, ( bp::arg("symbol") )
, "Return if this is a function of symbol" );
}
{ //::SireCAS::DoubleFunc::operator=
typedef ::SireCAS::DoubleFunc & ( ::SireCAS::DoubleFunc::*assign_function_type)( ::SireCAS::DoubleFunc const & ) ;
assign_function_type assign_function_value( &::SireCAS::DoubleFunc::operator= );
DoubleFunc_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
{ //::SireCAS::DoubleFunc::substitute
typedef ::SireCAS::Expression ( ::SireCAS::DoubleFunc::*substitute_function_type)( ::SireCAS::Identities const & ) const;
substitute_function_type substitute_function_value( &::SireCAS::DoubleFunc::substitute );
DoubleFunc_exposer.def(
"substitute"
, substitute_function_value
, ( bp::arg("identities") )
, "Substitute into this expression" );
}
{ //::SireCAS::DoubleFunc::symbols
typedef ::SireCAS::Symbols ( ::SireCAS::DoubleFunc::*symbols_function_type)( ) const;
symbols_function_type symbols_function_value( &::SireCAS::DoubleFunc::symbols );
DoubleFunc_exposer.def(
"symbols"
, symbols_function_value
, "Return the symbols used in this function" );
}
{ //::SireCAS::DoubleFunc::toString
typedef ::QString ( ::SireCAS::DoubleFunc::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireCAS::DoubleFunc::toString );
DoubleFunc_exposer.def(
"toString"
, toString_function_value
, "Return a string representation of this function" );
}
{ //::SireCAS::DoubleFunc::x
typedef ::SireCAS::Expression const & ( ::SireCAS::DoubleFunc::*x_function_type)( ) const;
x_function_type x_function_value( &::SireCAS::DoubleFunc::x );
DoubleFunc_exposer.def(
"x"
, x_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireCAS::DoubleFunc::y
typedef ::SireCAS::Expression const & ( ::SireCAS::DoubleFunc::*y_function_type)( ) const;
y_function_type y_function_value( &::SireCAS::DoubleFunc::y );
DoubleFunc_exposer.def(
"y"
, y_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
DoubleFunc_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::DoubleFunc >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
DoubleFunc_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::DoubleFunc >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
DoubleFunc_exposer.def( "__str__", &__str__< ::SireCAS::DoubleFunc > );
DoubleFunc_exposer.def( "__repr__", &__str__< ::SireCAS::DoubleFunc > );
DoubleFunc_exposer.def( "__hash__", &::SireCAS::DoubleFunc::hash );
}
}
void register_Expression_class(){
{ //::SireCAS::Expression
typedef bp::class_< SireCAS::Expression > Expression_exposer_t;
Expression_exposer_t Expression_exposer = Expression_exposer_t( "Expression", bp::init< >() );
bp::scope Expression_scope( Expression_exposer );
Expression_exposer.def( bp::init< int >(( bp::arg("constant") )) );
Expression_exposer.def( bp::init< SireMaths::Rational const & >(( bp::arg("constant") )) );
Expression_exposer.def( bp::init< double >(( bp::arg("constant") )) );
Expression_exposer.def( bp::init< SireMaths::Complex const & >(( bp::arg("constant") )) );
Expression_exposer.def( bp::init< SireCAS::ExpressionBase const & >(( bp::arg("base") )) );
Expression_exposer.def( bp::init< SireCAS::ExBase const & >(( bp::arg("base") )) );
Expression_exposer.def( bp::init< SireCAS::Expression const & >(( bp::arg("other") )) );
{ //::SireCAS::Expression::add
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*add_function_type )( ::SireCAS::Expression const & ) const;
add_function_type add_function_value( &::SireCAS::Expression::add );
Expression_exposer.def(
"add"
, add_function_value
, ( bp::arg("ex") ) );
}
{ //::SireCAS::Expression::add
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*add_function_type )( double ) const;
add_function_type add_function_value( &::SireCAS::Expression::add );
Expression_exposer.def(
"add"
, add_function_value
, ( bp::arg("val") ) );
}
{ //::SireCAS::Expression::add
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*add_function_type )( ::SireMaths::Complex const & ) const;
add_function_type add_function_value( &::SireCAS::Expression::add );
Expression_exposer.def(
"add"
, add_function_value
, ( bp::arg("val") ) );
}
{ //::SireCAS::Expression::base
typedef ::SireCAS::ExpressionBase const & ( ::SireCAS::Expression::*base_function_type )( ) const;
base_function_type base_function_value( &::SireCAS::Expression::base );
Expression_exposer.def(
"base"
, base_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireCAS::Expression::children
typedef ::SireCAS::Expressions ( ::SireCAS::Expression::*children_function_type )( ) const;
children_function_type children_function_value( &::SireCAS::Expression::children );
Expression_exposer.def(
"children"
, children_function_value );
}
{ //::SireCAS::Expression::conjugate
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*conjugate_function_type )( ) const;
conjugate_function_type conjugate_function_value( &::SireCAS::Expression::conjugate );
Expression_exposer.def(
"conjugate"
, conjugate_function_value );
}
{ //::SireCAS::Expression::cubed
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*cubed_function_type )( ) const;
cubed_function_type cubed_function_value( &::SireCAS::Expression::cubed );
Expression_exposer.def(
"cubed"
, cubed_function_value );
}
{ //::SireCAS::Expression::diff
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*diff_function_type )( ::SireCAS::Symbol const &,int ) const;
diff_function_type diff_function_value( &::SireCAS::Expression::diff );
Expression_exposer.def(
"diff"
, diff_function_value
, ( bp::arg("symbol"), bp::arg("level")=(int)(1) ) );
}
{ //::SireCAS::Expression::differentiate
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*differentiate_function_type )( ::SireCAS::Symbol const &,int ) const;
differentiate_function_type differentiate_function_value( &::SireCAS::Expression::differentiate );
Expression_exposer.def(
"differentiate"
, differentiate_function_value
, ( bp::arg("symbol"), bp::arg("level")=(int)(1) ) );
}
{ //::SireCAS::Expression::divide
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*divide_function_type )( ::SireCAS::Expression const & ) const;
divide_function_type divide_function_value( &::SireCAS::Expression::divide );
Expression_exposer.def(
"divide"
, divide_function_value
, ( bp::arg("ex") ) );
}
{ //::SireCAS::Expression::divide
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*divide_function_type )( double ) const;
divide_function_type divide_function_value( &::SireCAS::Expression::divide );
Expression_exposer.def(
"divide"
, divide_function_value
, ( bp::arg("val") ) );
}
{ //::SireCAS::Expression::divide
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*divide_function_type )( ::SireMaths::Complex const & ) const;
divide_function_type divide_function_value( &::SireCAS::Expression::divide );
Expression_exposer.def(
"divide"
, divide_function_value
, ( bp::arg("val") ) );
}
{ //::SireCAS::Expression::evaluate
typedef double ( ::SireCAS::Expression::*evaluate_function_type )( ::SireCAS::Values const & ) const;
evaluate_function_type evaluate_function_value( &::SireCAS::Expression::evaluate );
Expression_exposer.def(
"evaluate"
, evaluate_function_value
, ( bp::arg("values") ) );
}
{ //::SireCAS::Expression::evaluate
typedef ::SireMaths::Complex ( ::SireCAS::Expression::*evaluate_function_type )( ::SireCAS::ComplexValues const & ) const;
evaluate_function_type evaluate_function_value( &::SireCAS::Expression::evaluate );
Expression_exposer.def(
"evaluate"
, evaluate_function_value
, ( bp::arg("values") ) );
}
{ //::SireCAS::Expression::expand
typedef ::QList< SireCAS::Factor > ( ::SireCAS::Expression::*expand_function_type )( ::SireCAS::Symbol const & ) const;
expand_function_type expand_function_value( &::SireCAS::Expression::expand );
Expression_exposer.def(
"expand"
, expand_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireCAS::Expression::factor
typedef double ( ::SireCAS::Expression::*factor_function_type )( ) const;
factor_function_type factor_function_value( &::SireCAS::Expression::factor );
Expression_exposer.def(
"factor"
, factor_function_value );
}
{ //::SireCAS::Expression::functions
typedef ::SireCAS::Functions ( ::SireCAS::Expression::*functions_function_type )( ) const;
functions_function_type functions_function_value( &::SireCAS::Expression::functions );
Expression_exposer.def(
"functions"
, functions_function_value );
}
{ //::SireCAS::Expression::hash
typedef ::uint ( ::SireCAS::Expression::*hash_function_type )( ) const;
hash_function_type hash_function_value( &::SireCAS::Expression::hash );
Expression_exposer.def(
"hash"
, hash_function_value );
}
{ //::SireCAS::Expression::integ
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*integ_function_type )( ::SireCAS::Symbol const & ) const;
integ_function_type integ_function_value( &::SireCAS::Expression::integ );
Expression_exposer.def(
"integ"
, integ_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireCAS::Expression::integrate
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*integrate_function_type )( ::SireCAS::Symbol const & ) const;
integrate_function_type integrate_function_value( &::SireCAS::Expression::integrate );
Expression_exposer.def(
"integrate"
, integrate_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireCAS::Expression::invert
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*invert_function_type )( ) const;
invert_function_type invert_function_value( &::SireCAS::Expression::invert );
Expression_exposer.def(
"invert"
, invert_function_value );
}
{ //::SireCAS::Expression::isComplex
typedef bool ( ::SireCAS::Expression::*isComplex_function_type )( ) const;
isComplex_function_type isComplex_function_value( &::SireCAS::Expression::isComplex );
Expression_exposer.def(
"isComplex"
, isComplex_function_value );
}
{ //::SireCAS::Expression::isCompound
typedef bool ( ::SireCAS::Expression::*isCompound_function_type )( ) const;
isCompound_function_type isCompound_function_value( &::SireCAS::Expression::isCompound );
Expression_exposer.def(
"isCompound"
, isCompound_function_value );
}
{ //::SireCAS::Expression::isConstant
typedef bool ( ::SireCAS::Expression::*isConstant_function_type )( ) const;
isConstant_function_type isConstant_function_value( &::SireCAS::Expression::isConstant );
Expression_exposer.def(
"isConstant"
, isConstant_function_value );
}
{ //::SireCAS::Expression::isFunction
typedef bool ( ::SireCAS::Expression::*isFunction_function_type )( ::SireCAS::Symbol const & ) const;
isFunction_function_type isFunction_function_value( &::SireCAS::Expression::isFunction );
Expression_exposer.def(
"isFunction"
, isFunction_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireCAS::Expression::isZero
typedef bool ( ::SireCAS::Expression::*isZero_function_type )( ) const;
isZero_function_type isZero_function_value( &::SireCAS::Expression::isZero );
Expression_exposer.def(
"isZero"
, isZero_function_value );
}
{ //::SireCAS::Expression::multiply
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*multiply_function_type )( ::SireCAS::Expression const & ) const;
multiply_function_type multiply_function_value( &::SireCAS::Expression::multiply );
Expression_exposer.def(
"multiply"
, multiply_function_value
, ( bp::arg("ex") ) );
}
{ //::SireCAS::Expression::multiply
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*multiply_function_type )( double ) const;
multiply_function_type multiply_function_value( &::SireCAS::Expression::multiply );
Expression_exposer.def(
"multiply"
, multiply_function_value
, ( bp::arg("val") ) );
}
{ //::SireCAS::Expression::multiply
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*multiply_function_type )( ::SireMaths::Complex const & ) const;
multiply_function_type multiply_function_value( &::SireCAS::Expression::multiply );
Expression_exposer.def(
"multiply"
, multiply_function_value
, ( bp::arg("val") ) );
}
{ //::SireCAS::Expression::negate
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*negate_function_type )( ) const;
negate_function_type negate_function_value( &::SireCAS::Expression::negate );
Expression_exposer.def(
"negate"
, negate_function_value );
}
Expression_exposer.def( bp::self != bp::self );
{ //::SireCAS::Expression::operator()
typedef double ( ::SireCAS::Expression::*__call___function_type )( ::SireCAS::Values const & ) const;
__call___function_type __call___function_value( &::SireCAS::Expression::operator() );
Expression_exposer.def(
"__call__"
, __call___function_value
, ( bp::arg("values") ) );
}
{ //::SireCAS::Expression::operator()
typedef ::SireMaths::Complex ( ::SireCAS::Expression::*__call___function_type )( ::SireCAS::ComplexValues const & ) const;
__call___function_type __call___function_value( &::SireCAS::Expression::operator() );
Expression_exposer.def(
"__call__"
, __call___function_value
, ( bp::arg("values") ) );
}
Expression_exposer.def( -bp::self );
{ //::SireCAS::Expression::operator=
typedef ::SireCAS::Expression & ( ::SireCAS::Expression::*assign_function_type )( ::SireCAS::Expression const & ) ;
assign_function_type assign_function_value( &::SireCAS::Expression::operator= );
Expression_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
Expression_exposer.def( bp::self == bp::self );
{ //::SireCAS::Expression::pow
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( int ) const;
pow_function_type pow_function_value( &::SireCAS::Expression::pow );
Expression_exposer.def(
"pow"
, pow_function_value
, ( bp::arg("n") ) );
}
{ //::SireCAS::Expression::pow
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( ::SireMaths::Rational const & ) const;
pow_function_type pow_function_value( &::SireCAS::Expression::pow );
Expression_exposer.def(
"pow"
, pow_function_value
, ( bp::arg("n") ) );
}
{ //::SireCAS::Expression::pow
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( double ) const;
pow_function_type pow_function_value( &::SireCAS::Expression::pow );
Expression_exposer.def(
"pow"
, pow_function_value
, ( bp::arg("n") ) );
}
{ //::SireCAS::Expression::pow
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( ::SireMaths::Complex const & ) const;
pow_function_type pow_function_value( &::SireCAS::Expression::pow );
Expression_exposer.def(
"pow"
, pow_function_value
, ( bp::arg("n") ) );
}
{ //::SireCAS::Expression::pow
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( ::SireCAS::Expression const & ) const;
pow_function_type pow_function_value( &::SireCAS::Expression::pow );
Expression_exposer.def(
"pow"
, pow_function_value
, ( bp::arg("n") ) );
}
{ //::SireCAS::Expression::root
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*root_function_type )( int ) const;
root_function_type root_function_value( &::SireCAS::Expression::root );
Expression_exposer.def(
"root"
, root_function_value
, ( bp::arg("n") ) );
}
{ //::SireCAS::Expression::series
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*series_function_type )( ::SireCAS::Symbol const &,int ) const;
series_function_type series_function_value( &::SireCAS::Expression::series );
Expression_exposer.def(
"series"
, series_function_value
, ( bp::arg("symbol"), bp::arg("order") ) );
}
{ //::SireCAS::Expression::simplify
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*simplify_function_type )( int ) const;
simplify_function_type simplify_function_value( &::SireCAS::Expression::simplify );
Expression_exposer.def(
"simplify"
, simplify_function_value
, ( bp::arg("options")=(int)(0) ) );
}
{ //::SireCAS::Expression::squared
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*squared_function_type )( ) const;
squared_function_type squared_function_value( &::SireCAS::Expression::squared );
Expression_exposer.def(
"squared"
, squared_function_value );
}
{ //::SireCAS::Expression::substitute
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*substitute_function_type )( ::SireCAS::Identities const & ) const;
substitute_function_type substitute_function_value( &::SireCAS::Expression::substitute );
Expression_exposer.def(
"substitute"
, substitute_function_value
, ( bp::arg("identities") ) );
}
{ //::SireCAS::Expression::subtract
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*subtract_function_type )( ::SireCAS::Expression const & ) const;
subtract_function_type subtract_function_value( &::SireCAS::Expression::subtract );
Expression_exposer.def(
"subtract"
, subtract_function_value
, ( bp::arg("ex") ) );
}
{ //::SireCAS::Expression::subtract
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*subtract_function_type )( double ) const;
subtract_function_type subtract_function_value( &::SireCAS::Expression::subtract );
Expression_exposer.def(
"subtract"
, subtract_function_value
, ( bp::arg("val") ) );
}
{ //::SireCAS::Expression::subtract
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*subtract_function_type )( ::SireMaths::Complex const & ) const;
subtract_function_type subtract_function_value( &::SireCAS::Expression::subtract );
Expression_exposer.def(
"subtract"
, subtract_function_value
, ( bp::arg("val") ) );
}
{ //::SireCAS::Expression::symbols
typedef ::SireCAS::Symbols ( ::SireCAS::Expression::*symbols_function_type )( ) const;
symbols_function_type symbols_function_value( &::SireCAS::Expression::symbols );
Expression_exposer.def(
"symbols"
, symbols_function_value );
}
{ //::SireCAS::Expression::toString
typedef ::QString ( ::SireCAS::Expression::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireCAS::Expression::toString );
Expression_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireCAS::Expression::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireCAS::Expression::typeName );
Expression_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireCAS::Expression::what
typedef char const * ( ::SireCAS::Expression::*what_function_type )( ) const;
what_function_type what_function_value( &::SireCAS::Expression::what );
Expression_exposer.def(
"what"
, what_function_value );
}
Expression_exposer.staticmethod( "typeName" );
Expression_exposer.def( bp::self * bp::other< SireMaths::Complex >() );
Expression_exposer.def( bp::other< SireMaths::Complex >() * bp::self );
Expression_exposer.def( bp::self * bp::other< double >() );
Expression_exposer.def( bp::other< double >() * bp::self );
Expression_exposer.def( bp::self * bp::self );
Expression_exposer.def( bp::self * bp::other< SireCAS::ExBase >() );
Expression_exposer.def( bp::other< SireMaths::Complex >() + bp::self );
Expression_exposer.def( bp::self + bp::other< SireMaths::Complex >() );
Expression_exposer.def( bp::other< double >() + bp::self );
Expression_exposer.def( bp::self + bp::other< double >() );
Expression_exposer.def( bp::self + bp::self );
Expression_exposer.def( bp::self + bp::other< SireCAS::ExBase >() );
Expression_exposer.def( bp::other< double >() - bp::self );
Expression_exposer.def( bp::self - bp::other< double >() );
Expression_exposer.def( bp::self - bp::self );
Expression_exposer.def( bp::self - bp::other< SireCAS::ExBase >() );
Expression_exposer.def( bp::other< SireMaths::Complex >() / bp::self );
Expression_exposer.def( bp::self / bp::other< SireMaths::Complex >() );
Expression_exposer.def( bp::other< double >() / bp::self );
Expression_exposer.def( bp::self / bp::other< double >() );
Expression_exposer.def( bp::self / bp::self );
Expression_exposer.def( bp::self / bp::other< SireCAS::ExBase >() );
Expression_exposer.def( self + self );
Expression_exposer.def( self - self );
Expression_exposer.def( self * self );
Expression_exposer.def( self / self );
Expression_exposer.def( other<double>() + self );
Expression_exposer.def( other<double>() - self );
Expression_exposer.def( other<double>() * self );
Expression_exposer.def( other<double>() / self );
Expression_exposer.def( self + other<double>() );
Expression_exposer.def( self - other<double>() );
Expression_exposer.def( self * other<double>() );
Expression_exposer.def( self / other<double>() );
Expression_exposer.def( other<SireMaths::Complex>() + self );
Expression_exposer.def( other<SireMaths::Complex>() - self );
Expression_exposer.def( other<SireMaths::Complex>() * self );
Expression_exposer.def( other<SireMaths::Complex>() / self );
Expression_exposer.def( self + other<SireMaths::Complex>() );
Expression_exposer.def( self - other<SireMaths::Complex>() );
Expression_exposer.def( self * other<SireMaths::Complex>() );
Expression_exposer.def( self / other<SireMaths::Complex>() );
Expression_exposer.def( other<SireCAS::ExBase>() + self );
Expression_exposer.def( other<SireCAS::ExBase>() - self );
Expression_exposer.def( other<SireCAS::ExBase>() * self );
Expression_exposer.def( other<SireCAS::ExBase>() / self );
Expression_exposer.def( self + other<SireCAS::ExBase>() );
Expression_exposer.def( self - other<SireCAS::ExBase>() );
Expression_exposer.def( self * other<SireCAS::ExBase>() );
Expression_exposer.def( self / other<SireCAS::ExBase>() );
Expression_exposer.def( "__copy__", &__copy__);
Expression_exposer.def( "__deepcopy__", &__copy__);
Expression_exposer.def( "clone", &__copy__);
Expression_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::Expression >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Expression_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::Expression >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Expression_exposer.def( "__str__", &__str__< ::SireCAS::Expression > );
Expression_exposer.def( "__repr__", &__str__< ::SireCAS::Expression > );
}
}
void register_CLJWorkspace_class(){
{ //::SireMM::CLJWorkspace
typedef bp::class_< SireMM::CLJWorkspace > CLJWorkspace_exposer_t;
CLJWorkspace_exposer_t CLJWorkspace_exposer = CLJWorkspace_exposer_t( "CLJWorkspace", "This class provides a workspace in which to hold the details of the changes\nthat occur in a CLJ forcefield during a Monte Carlo move. The class is optimised\nto avoid copying or duplicating data during Sires copy-on-write copying\n(e.g. the memory allocated in a workspace will always be available for the\nnew copy of a forcefield rather than the old, which, if things work correctly,\nwill mean that there should be no memory allocation during simple MC moves...)\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") );
bp::scope CLJWorkspace_scope( CLJWorkspace_exposer );
CLJWorkspace_exposer.def( bp::init< SireMM::CLJWorkspace const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireMM::CLJWorkspace::accept
typedef void ( ::SireMM::CLJWorkspace::*accept_function_type)( ::SireMM::CLJBoxes & ) ;
accept_function_type accept_function_value( &::SireMM::CLJWorkspace::accept );
CLJWorkspace_exposer.def(
"accept"
, accept_function_value
, ( bp::arg("boxes") )
, "Accept this workspace - this clears the recalc_from_scratch flag as it\nsignals that we have put the CLJBoxes into a sane state" );
}
{ //::SireMM::CLJWorkspace::at
typedef ::SireMM::CLJDelta const & ( ::SireMM::CLJWorkspace::*at_function_type)( int ) const;
at_function_type at_function_value( &::SireMM::CLJWorkspace::at );
CLJWorkspace_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the ith delta" );
}
{ //::SireMM::CLJWorkspace::changedAtoms
typedef ::SireMM::CLJAtoms ( ::SireMM::CLJWorkspace::*changedAtoms_function_type)( ) const;
changedAtoms_function_type changedAtoms_function_value( &::SireMM::CLJWorkspace::changedAtoms );
CLJWorkspace_exposer.def(
"changedAtoms"
, changedAtoms_function_value
, "Merge all of the deltas together into a single set of changed CLJAtoms that\ncan be used for the change in energy calculation" );
}
{ //::SireMM::CLJWorkspace::clear
typedef void ( ::SireMM::CLJWorkspace::*clear_function_type)( ) ;
clear_function_type clear_function_value( &::SireMM::CLJWorkspace::clear );
CLJWorkspace_exposer.def(
"clear"
, clear_function_value
, "Clear this workspace" );
}
{ //::SireMM::CLJWorkspace::commit
typedef ::QVector< SireMM::CLJBoxIndex > ( ::SireMM::CLJWorkspace::*commit_function_type)( ::SireMM::CLJBoxes &,::SireMM::CLJDelta const & ) ;
commit_function_type commit_function_value( &::SireMM::CLJWorkspace::commit );
CLJWorkspace_exposer.def(
"commit"
, commit_function_value
, ( bp::arg("boxes"), bp::arg("delta") )
, "Commit the changes in the passed delta into the passed CLJBoxes" );
}
{ //::SireMM::CLJWorkspace::count
typedef int ( ::SireMM::CLJWorkspace::*count_function_type)( ) const;
count_function_type count_function_value( &::SireMM::CLJWorkspace::count );
CLJWorkspace_exposer.def(
"count"
, count_function_value
, "Return the number of deltas" );
}
{ //::SireMM::CLJWorkspace::getitem
typedef ::SireMM::CLJDelta ( ::SireMM::CLJWorkspace::*getitem_function_type)( int ) const;
getitem_function_type getitem_function_value( &::SireMM::CLJWorkspace::getitem );
CLJWorkspace_exposer.def(
"getitem"
, getitem_function_value
, ( bp::arg("i") )
, "Return the ith delta" );
}
{ //::SireMM::CLJWorkspace::isEmpty
typedef bool ( ::SireMM::CLJWorkspace::*isEmpty_function_type)( ) const;
isEmpty_function_type isEmpty_function_value( &::SireMM::CLJWorkspace::isEmpty );
CLJWorkspace_exposer.def(
"isEmpty"
, isEmpty_function_value
, "Return whether or not this workspace is empty" );
}
{ //::SireMM::CLJWorkspace::isSingleID
typedef bool ( ::SireMM::CLJWorkspace::*isSingleID_function_type)( ) const;
isSingleID_function_type isSingleID_function_value( &::SireMM::CLJWorkspace::isSingleID );
CLJWorkspace_exposer.def(
"isSingleID"
, isSingleID_function_value
, "Return whether or not this workspace contains deltas with a single\nID (a single CLJAtoms ID)" );
}
{ //::SireMM::CLJWorkspace::merge
typedef ::boost::tuples::tuple< SireMM::CLJAtoms, SireMM::CLJAtoms, SireMM::CLJAtoms, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type > ( ::SireMM::CLJWorkspace::*merge_function_type)( ) const;
merge_function_type merge_function_value( &::SireMM::CLJWorkspace::merge );
CLJWorkspace_exposer.def(
"merge"
, merge_function_value
, "Merge all of the deltas together to return the tuple of the\nchanged, old and new atoms. This is equivalent to calling\nchangedAtoms(), oldAtoms() and newAtoms() and placing them\ninto a tuple. This is more efficient than three separate calls" );
}
{ //::SireMM::CLJWorkspace::mustRecalculateFromScratch
typedef void ( ::SireMM::CLJWorkspace::*mustRecalculateFromScratch_function_type)( ::SireMM::CLJBoxes & ) ;
mustRecalculateFromScratch_function_type mustRecalculateFromScratch_function_value( &::SireMM::CLJWorkspace::mustRecalculateFromScratch );
CLJWorkspace_exposer.def(
"mustRecalculateFromScratch"
, mustRecalculateFromScratch_function_value
, ( bp::arg("boxes") )
, "Tell the workspace that we are now recalculating everything from scratch" );
}
{ //::SireMM::CLJWorkspace::nDeltas
typedef int ( ::SireMM::CLJWorkspace::*nDeltas_function_type)( ) const;
nDeltas_function_type nDeltas_function_value( &::SireMM::CLJWorkspace::nDeltas );
CLJWorkspace_exposer.def(
"nDeltas"
, nDeltas_function_value
, "Return the number of deltas in this workspace" );
}
{ //::SireMM::CLJWorkspace::needsAccepting
typedef bool ( ::SireMM::CLJWorkspace::*needsAccepting_function_type)( ) const;
needsAccepting_function_type needsAccepting_function_value( &::SireMM::CLJWorkspace::needsAccepting );
CLJWorkspace_exposer.def(
"needsAccepting"
, needsAccepting_function_value
, "Return whether or not this workspace needs accepting" );
}
{ //::SireMM::CLJWorkspace::newAtoms
typedef ::SireMM::CLJAtoms ( ::SireMM::CLJWorkspace::*newAtoms_function_type)( ) const;
newAtoms_function_type newAtoms_function_value( &::SireMM::CLJWorkspace::newAtoms );
CLJWorkspace_exposer.def(
"newAtoms"
, newAtoms_function_value
, "Merge all of the new atoms from the deltas together into a single\nset of new CLJAtoms that can be used for the change in energy calculation" );
}
{ //::SireMM::CLJWorkspace::oldAtoms
typedef ::SireMM::CLJAtoms ( ::SireMM::CLJWorkspace::*oldAtoms_function_type)( ) const;
oldAtoms_function_type oldAtoms_function_value( &::SireMM::CLJWorkspace::oldAtoms );
CLJWorkspace_exposer.def(
"oldAtoms"
, oldAtoms_function_value
, "Merge all of the old atoms from the deltas together into a single\nset of old CLJAtoms that can be used for the change in energy calculation" );
}
CLJWorkspace_exposer.def( bp::self != bp::self );
{ //::SireMM::CLJWorkspace::operator=
typedef ::SireMM::CLJWorkspace & ( ::SireMM::CLJWorkspace::*assign_function_type)( ::SireMM::CLJWorkspace const & ) ;
assign_function_type assign_function_value( &::SireMM::CLJWorkspace::operator= );
CLJWorkspace_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
CLJWorkspace_exposer.def( bp::self == bp::self );
{ //::SireMM::CLJWorkspace::operator[]
typedef ::SireMM::CLJDelta const & ( ::SireMM::CLJWorkspace::*__getitem___function_type)( int ) const;
__getitem___function_type __getitem___function_value( &::SireMM::CLJWorkspace::operator[] );
CLJWorkspace_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMM::CLJWorkspace::push
typedef ::SireMM::CLJDelta ( ::SireMM::CLJWorkspace::*push_function_type)( ::SireMM::CLJBoxes &,::QVector< SireMM::CLJBoxIndex > const &,::SireMM::CLJAtoms const &,::SireMM::CLJDelta const & ) ;
push_function_type push_function_value( &::SireMM::CLJWorkspace::push );
CLJWorkspace_exposer.def(
"push"
, push_function_value
, ( bp::arg("boxes"), bp::arg("old_atoms"), bp::arg("new_atoms"), bp::arg("old_delta") )
, "Push the passed change onto the workspace. This changes the atoms in the\npassed CLJBoxes from their values in old_atoms to their values in the\npassed new_atoms. The last CLJDelta used for these atoms is supplied as\nold_delta, and this returns the new CLJDelta for these atoms." );
}
{ //::SireMM::CLJWorkspace::recalculatingFromScratch
typedef bool ( ::SireMM::CLJWorkspace::*recalculatingFromScratch_function_type)( ) const;
recalculatingFromScratch_function_type recalculatingFromScratch_function_value( &::SireMM::CLJWorkspace::recalculatingFromScratch );
CLJWorkspace_exposer.def(
"recalculatingFromScratch"
, recalculatingFromScratch_function_value
, "Return whether or not we are recalculating everything from scratch" );
}
{ //::SireMM::CLJWorkspace::removeSameIDAtoms
typedef void ( ::SireMM::CLJWorkspace::*removeSameIDAtoms_function_type)( ::SireMM::CLJBoxes & ) ;
removeSameIDAtoms_function_type removeSameIDAtoms_function_value( &::SireMM::CLJWorkspace::removeSameIDAtoms );
CLJWorkspace_exposer.def(
"removeSameIDAtoms"
, removeSameIDAtoms_function_value
, ( bp::arg("boxes") )
, "Internal function used to fully remove atoms that have not been\nremoved because they all have the same ID. This is used when the\noptimisation of not removing same ID atoms would break the energy\ncalculation, e.g. if we have multiple CLJGroups and have multiple\nchanged IDs across these groups" );
}
{ //::SireMM::CLJWorkspace::revert
typedef ::QVector< SireMM::CLJBoxIndex > ( ::SireMM::CLJWorkspace::*revert_function_type)( ::SireMM::CLJBoxes &,::SireMM::CLJDelta const & ) ;
revert_function_type revert_function_value( &::SireMM::CLJWorkspace::revert );
CLJWorkspace_exposer.def(
"revert"
, revert_function_value
, ( bp::arg("boxes"), bp::arg("delta") )
, "Revert the changes supplied in the passed delta" );
}
{ //::SireMM::CLJWorkspace::size
typedef int ( ::SireMM::CLJWorkspace::*size_function_type)( ) const;
size_function_type size_function_value( &::SireMM::CLJWorkspace::size );
CLJWorkspace_exposer.def(
"size"
, size_function_value
, "Return the number of deltas" );
}
{ //::SireMM::CLJWorkspace::toString
typedef ::QString ( ::SireMM::CLJWorkspace::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMM::CLJWorkspace::toString );
CLJWorkspace_exposer.def(
"toString"
, toString_function_value
, "" );
}
{ //::SireMM::CLJWorkspace::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMM::CLJWorkspace::typeName );
CLJWorkspace_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireMM::CLJWorkspace::what
typedef char const * ( ::SireMM::CLJWorkspace::*what_function_type)( ) const;
what_function_type what_function_value( &::SireMM::CLJWorkspace::what );
CLJWorkspace_exposer.def(
"what"
, what_function_value
, "" );
}
CLJWorkspace_exposer.staticmethod( "typeName" );
CLJWorkspace_exposer.def( "__copy__", &__copy__);
CLJWorkspace_exposer.def( "__deepcopy__", &__copy__);
CLJWorkspace_exposer.def( "clone", &__copy__);
CLJWorkspace_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::CLJWorkspace >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CLJWorkspace_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::CLJWorkspace >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CLJWorkspace_exposer.def( "__str__", &__str__< ::SireMM::CLJWorkspace > );
CLJWorkspace_exposer.def( "__repr__", &__str__< ::SireMM::CLJWorkspace > );
CLJWorkspace_exposer.def( "__len__", &__len_size< ::SireMM::CLJWorkspace > );
CLJWorkspace_exposer.def( "__getitem__", &::SireMM::CLJWorkspace::getitem );
}
}
void register_LJParameter_class(){
{ //::SireMM::LJParameter
typedef bp::class_< SireMM::LJParameter > LJParameter_exposer_t;
LJParameter_exposer_t LJParameter_exposer = LJParameter_exposer_t( "LJParameter", bp::init< >() );
bp::scope LJParameter_scope( LJParameter_exposer );
LJParameter_exposer.def( bp::init< SireUnits::Dimension::Length, SireUnits::Dimension::MolarEnergy >(( bp::arg("sigma"), bp::arg("epsilon") )) );
LJParameter_exposer.def( bp::init< SireMM::LJPair const & >(( bp::arg("ljpair") )) );
LJParameter_exposer.def( bp::init< SireMM::LJParameter const & >(( bp::arg("param") )) );
{ //::SireMM::LJParameter::A
typedef double ( ::SireMM::LJParameter::*A_function_type )( ) const;
A_function_type A_function_value( &::SireMM::LJParameter::A );
LJParameter_exposer.def(
"A"
, A_function_value );
}
{ //::SireMM::LJParameter::B
typedef double ( ::SireMM::LJParameter::*B_function_type )( ) const;
B_function_type B_function_value( &::SireMM::LJParameter::B );
LJParameter_exposer.def(
"B"
, B_function_value );
}
{ //::SireMM::LJParameter::dummy
typedef ::SireMM::LJParameter ( *dummy_function_type )( );
dummy_function_type dummy_function_value( &::SireMM::LJParameter::dummy );
LJParameter_exposer.def(
"dummy"
, dummy_function_value );
}
{ //::SireMM::LJParameter::epsilon
typedef ::SireUnits::Dimension::MolarEnergy ( ::SireMM::LJParameter::*epsilon_function_type )( ) const;
epsilon_function_type epsilon_function_value( &::SireMM::LJParameter::epsilon );
LJParameter_exposer.def(
"epsilon"
, epsilon_function_value );
}
{ //::SireMM::LJParameter::fromAAndB
typedef ::SireMM::LJParameter ( *fromAAndB_function_type )( double,double );
fromAAndB_function_type fromAAndB_function_value( &::SireMM::LJParameter::fromAAndB );
LJParameter_exposer.def(
"fromAAndB"
, fromAAndB_function_value
, ( bp::arg("a"), bp::arg("b") ) );
}
{ //::SireMM::LJParameter::fromRMinAndEpsilon
typedef ::SireMM::LJParameter ( *fromRMinAndEpsilon_function_type )( ::SireUnits::Dimension::Length,::SireUnits::Dimension::MolarEnergy );
fromRMinAndEpsilon_function_type fromRMinAndEpsilon_function_value( &::SireMM::LJParameter::fromRMinAndEpsilon );
LJParameter_exposer.def(
"fromRMinAndEpsilon"
, fromRMinAndEpsilon_function_value
, ( bp::arg("rmin"), bp::arg("epsilon") ) );
}
{ //::SireMM::LJParameter::fromSigmaAndEpsilon
typedef ::SireMM::LJParameter ( *fromSigmaAndEpsilon_function_type )( ::SireUnits::Dimension::Length,::SireUnits::Dimension::MolarEnergy );
fromSigmaAndEpsilon_function_type fromSigmaAndEpsilon_function_value( &::SireMM::LJParameter::fromSigmaAndEpsilon );
LJParameter_exposer.def(
"fromSigmaAndEpsilon"
, fromSigmaAndEpsilon_function_value
, ( bp::arg("sigma"), bp::arg("epsilon") ) );
}
{ //::SireMM::LJParameter::isDummy
typedef bool ( ::SireMM::LJParameter::*isDummy_function_type )( ) const;
isDummy_function_type isDummy_function_value( &::SireMM::LJParameter::isDummy );
LJParameter_exposer.def(
"isDummy"
, isDummy_function_value );
}
LJParameter_exposer.def( bp::self != bp::self );
LJParameter_exposer.def( bp::self == bp::self );
{ //::SireMM::LJParameter::rmin
typedef ::SireUnits::Dimension::Length ( ::SireMM::LJParameter::*rmin_function_type )( ) const;
rmin_function_type rmin_function_value( &::SireMM::LJParameter::rmin );
LJParameter_exposer.def(
"rmin"
, rmin_function_value );
}
{ //::SireMM::LJParameter::sigma
typedef ::SireUnits::Dimension::Length ( ::SireMM::LJParameter::*sigma_function_type )( ) const;
sigma_function_type sigma_function_value( &::SireMM::LJParameter::sigma );
LJParameter_exposer.def(
"sigma"
, sigma_function_value );
}
{ //::SireMM::LJParameter::sqrtEpsilon
typedef double ( ::SireMM::LJParameter::*sqrtEpsilon_function_type )( ) const;
sqrtEpsilon_function_type sqrtEpsilon_function_value( &::SireMM::LJParameter::sqrtEpsilon );
LJParameter_exposer.def(
"sqrtEpsilon"
, sqrtEpsilon_function_value );
}
{ //::SireMM::LJParameter::sqrtSigma
typedef double ( ::SireMM::LJParameter::*sqrtSigma_function_type )( ) const;
sqrtSigma_function_type sqrtSigma_function_value( &::SireMM::LJParameter::sqrtSigma );
LJParameter_exposer.def(
"sqrtSigma"
, sqrtSigma_function_value );
}
{ //::SireMM::LJParameter::toString
typedef ::QString ( ::SireMM::LJParameter::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMM::LJParameter::toString );
LJParameter_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMM::LJParameter::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMM::LJParameter::typeName );
LJParameter_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMM::LJParameter::what
typedef char const * ( ::SireMM::LJParameter::*what_function_type )( ) const;
what_function_type what_function_value( &::SireMM::LJParameter::what );
LJParameter_exposer.def(
"what"
, what_function_value );
}
{ //::SireMM::LJParameter::zeroLJ
typedef bool ( ::SireMM::LJParameter::*zeroLJ_function_type )( ) const;
zeroLJ_function_type zeroLJ_function_value( &::SireMM::LJParameter::zeroLJ );
LJParameter_exposer.def(
"zeroLJ"
, zeroLJ_function_value );
}
LJParameter_exposer.staticmethod( "dummy" );
LJParameter_exposer.staticmethod( "fromAAndB" );
LJParameter_exposer.staticmethod( "fromRMinAndEpsilon" );
LJParameter_exposer.staticmethod( "fromSigmaAndEpsilon" );
LJParameter_exposer.staticmethod( "typeName" );
LJParameter_exposer.def( "__copy__", &__copy__);
LJParameter_exposer.def( "__deepcopy__", &__copy__);
LJParameter_exposer.def( "clone", &__copy__);
LJParameter_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::LJParameter >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
LJParameter_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::LJParameter >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
LJParameter_exposer.def( "__str__", &__str__< ::SireMM::LJParameter > );
LJParameter_exposer.def( "__repr__", &__str__< ::SireMM::LJParameter > );
}
}
void register_AtomMultiMatcher_class(){
{ //::SireMol::AtomMultiMatcher
typedef bp::class_< SireMol::AtomMultiMatcher, bp::bases< SireMol::AtomMatcher, SireBase::Property > > AtomMultiMatcher_exposer_t;
AtomMultiMatcher_exposer_t AtomMultiMatcher_exposer = AtomMultiMatcher_exposer_t( "AtomMultiMatcher", "This is an atom matcher combines several sub-AtomMatchers together\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") );
bp::scope AtomMultiMatcher_scope( AtomMultiMatcher_exposer );
AtomMultiMatcher_exposer.def( bp::init< SireMol::AtomMatcher const & >(( bp::arg("matcher") ), "Construct from a single match") );
AtomMultiMatcher_exposer.def( bp::init< SireMol::AtomMatcher const &, SireMol::AtomMatcher const & >(( bp::arg("m0"), bp::arg("m1") ), "Construct from a pair of matches") );
AtomMultiMatcher_exposer.def( bp::init< SireMol::AtomMultiMatcher const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireMol::AtomMultiMatcher::isNull
typedef bool ( ::SireMol::AtomMultiMatcher::*isNull_function_type)( ) const;
isNull_function_type isNull_function_value( &::SireMol::AtomMultiMatcher::isNull );
AtomMultiMatcher_exposer.def(
"isNull"
, isNull_function_value
, "Return whether or not this matcher is null (cannot be used for matching)" );
}
AtomMultiMatcher_exposer.def( bp::self != bp::self );
{ //::SireMol::AtomMultiMatcher::operator=
typedef ::SireMol::AtomMultiMatcher & ( ::SireMol::AtomMultiMatcher::*assign_function_type)( ::SireMol::AtomMultiMatcher const & ) ;
assign_function_type assign_function_value( &::SireMol::AtomMultiMatcher::operator= );
AtomMultiMatcher_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
AtomMultiMatcher_exposer.def( bp::self == bp::self );
{ //::SireMol::AtomMultiMatcher::toString
typedef ::QString ( ::SireMol::AtomMultiMatcher::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMol::AtomMultiMatcher::toString );
AtomMultiMatcher_exposer.def(
"toString"
, toString_function_value
, "" );
}
{ //::SireMol::AtomMultiMatcher::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::AtomMultiMatcher::typeName );
AtomMultiMatcher_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireMol::AtomMultiMatcher::what
typedef char const * ( ::SireMol::AtomMultiMatcher::*what_function_type)( ) const;
what_function_type what_function_value( &::SireMol::AtomMultiMatcher::what );
AtomMultiMatcher_exposer.def(
"what"
, what_function_value
, "" );
}
AtomMultiMatcher_exposer.staticmethod( "typeName" );
AtomMultiMatcher_exposer.def( "__copy__", &__copy__);
AtomMultiMatcher_exposer.def( "__deepcopy__", &__copy__);
AtomMultiMatcher_exposer.def( "clone", &__copy__);
AtomMultiMatcher_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::AtomMultiMatcher >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
AtomMultiMatcher_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::AtomMultiMatcher >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
AtomMultiMatcher_exposer.def( "__str__", &__str__< ::SireMol::AtomMultiMatcher > );
AtomMultiMatcher_exposer.def( "__repr__", &__str__< ::SireMol::AtomMultiMatcher > );
}
}
void register_Nodes_class(){
{ //::SireCluster::Nodes
typedef bp::class_< SireCluster::Nodes > Nodes_exposer_t;
Nodes_exposer_t Nodes_exposer = Nodes_exposer_t( "Nodes", bp::init< >() );
bp::scope Nodes_scope( Nodes_exposer );
Nodes_exposer.def( bp::init< SireCluster::Nodes const & >(( bp::arg("other") )) );
{ //::SireCluster::Nodes::add
typedef void ( ::SireCluster::Nodes::*add_function_type )( ::SireCluster::Node ) ;
add_function_type add_function_value( &::SireCluster::Nodes::add );
Nodes_exposer.def(
"add"
, add_function_value
, ( bp::arg("node") ) );
}
{ //::SireCluster::Nodes::add
typedef void ( ::SireCluster::Nodes::*add_function_type )( ::SireCluster::Nodes & ) ;
add_function_type add_function_value( &::SireCluster::Nodes::add );
Nodes_exposer.def(
"add"
, add_function_value
, ( bp::arg("nodes") ) );
}
{ //::SireCluster::Nodes::addNode
typedef void ( ::SireCluster::Nodes::*addNode_function_type )( ) ;
addNode_function_type addNode_function_value( &::SireCluster::Nodes::addNode );
Nodes_exposer.def(
"addNode"
, addNode_function_value );
}
{ //::SireCluster::Nodes::addNode
typedef void ( ::SireCluster::Nodes::*addNode_function_type )( int ) ;
addNode_function_type addNode_function_value( &::SireCluster::Nodes::addNode );
Nodes_exposer.def(
"addNode"
, addNode_function_value
, ( bp::arg("timeout") ) );
}
{ //::SireCluster::Nodes::addNodes
typedef void ( ::SireCluster::Nodes::*addNodes_function_type )( int ) ;
addNodes_function_type addNodes_function_value( &::SireCluster::Nodes::addNodes );
Nodes_exposer.def(
"addNodes"
, addNodes_function_value
, ( bp::arg("n") ) );
}
{ //::SireCluster::Nodes::addNodes
typedef void ( ::SireCluster::Nodes::*addNodes_function_type )( int,int ) ;
addNodes_function_type addNodes_function_value( &::SireCluster::Nodes::addNodes );
Nodes_exposer.def(
"addNodes"
, addNodes_function_value
, ( bp::arg("n"), bp::arg("timeout") ) );
}
{ //::SireCluster::Nodes::borrowThisThread
typedef ::SireCluster::ThisThread ( ::SireCluster::Nodes::*borrowThisThread_function_type )( ) ;
borrowThisThread_function_type borrowThisThread_function_value( &::SireCluster::Nodes::borrowThisThread );
Nodes_exposer.def(
"borrowThisThread"
, borrowThisThread_function_value );
}
{ //::SireCluster::Nodes::count
typedef int ( ::SireCluster::Nodes::*count_function_type )( ) ;
count_function_type count_function_value( &::SireCluster::Nodes::count );
Nodes_exposer.def(
"count"
, count_function_value );
}
{ //::SireCluster::Nodes::getAllNodes
typedef ::QList< SireCluster::Node > ( ::SireCluster::Nodes::*getAllNodes_function_type )( ) ;
getAllNodes_function_type getAllNodes_function_value( &::SireCluster::Nodes::getAllNodes );
Nodes_exposer.def(
"getAllNodes"
, getAllNodes_function_value );
}
{ //::SireCluster::Nodes::getAllNodes
typedef ::QList< SireCluster::Node > ( ::SireCluster::Nodes::*getAllNodes_function_type )( int ) ;
getAllNodes_function_type getAllNodes_function_value( &::SireCluster::Nodes::getAllNodes );
Nodes_exposer.def(
"getAllNodes"
, getAllNodes_function_value
, ( bp::arg("timeout") ) );
}
{ //::SireCluster::Nodes::getNode
typedef ::SireCluster::Node ( ::SireCluster::Nodes::*getNode_function_type )( ) ;
getNode_function_type getNode_function_value( &::SireCluster::Nodes::getNode );
Nodes_exposer.def(
"getNode"
, getNode_function_value );
}
{ //::SireCluster::Nodes::getNode
typedef ::SireCluster::Node ( ::SireCluster::Nodes::*getNode_function_type )( int ) ;
getNode_function_type getNode_function_value( &::SireCluster::Nodes::getNode );
Nodes_exposer.def(
"getNode"
, getNode_function_value
, ( bp::arg("timeout") ) );
}
{ //::SireCluster::Nodes::getNodes
typedef ::QList< SireCluster::Node > ( ::SireCluster::Nodes::*getNodes_function_type )( int ) ;
getNodes_function_type getNodes_function_value( &::SireCluster::Nodes::getNodes );
Nodes_exposer.def(
"getNodes"
, getNodes_function_value
, ( bp::arg("n") ) );
}
{ //::SireCluster::Nodes::getNodes
typedef ::QList< SireCluster::Node > ( ::SireCluster::Nodes::*getNodes_function_type )( int,int ) ;
getNodes_function_type getNodes_function_value( &::SireCluster::Nodes::getNodes );
Nodes_exposer.def(
"getNodes"
, getNodes_function_value
, ( bp::arg("n"), bp::arg("timeout") ) );
}
{ //::SireCluster::Nodes::isEmpty
typedef bool ( ::SireCluster::Nodes::*isEmpty_function_type )( ) ;
isEmpty_function_type isEmpty_function_value( &::SireCluster::Nodes::isEmpty );
Nodes_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireCluster::Nodes::nBusy
typedef int ( ::SireCluster::Nodes::*nBusy_function_type )( ) ;
nBusy_function_type nBusy_function_value( &::SireCluster::Nodes::nBusy );
Nodes_exposer.def(
"nBusy"
, nBusy_function_value );
}
{ //::SireCluster::Nodes::nFree
typedef int ( ::SireCluster::Nodes::*nFree_function_type )( ) ;
nFree_function_type nFree_function_value( &::SireCluster::Nodes::nFree );
Nodes_exposer.def(
"nFree"
, nFree_function_value );
}
{ //::SireCluster::Nodes::nNodes
typedef int ( ::SireCluster::Nodes::*nNodes_function_type )( ) ;
nNodes_function_type nNodes_function_value( &::SireCluster::Nodes::nNodes );
Nodes_exposer.def(
"nNodes"
, nNodes_function_value );
}
Nodes_exposer.def( bp::self != bp::self );
{ //::SireCluster::Nodes::operator=
typedef ::SireCluster::Nodes & ( ::SireCluster::Nodes::*assign_function_type )( ::SireCluster::Nodes const & ) ;
assign_function_type assign_function_value( &::SireCluster::Nodes::operator= );
Nodes_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
Nodes_exposer.def( bp::self == bp::self );
{ //::SireCluster::Nodes::remove
typedef void ( ::SireCluster::Nodes::*remove_function_type )( ::SireCluster::Node ) ;
remove_function_type remove_function_value( &::SireCluster::Nodes::remove );
Nodes_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("node") ) );
}
{ //::SireCluster::Nodes::removeAll
typedef void ( ::SireCluster::Nodes::*removeAll_function_type )( ) ;
removeAll_function_type removeAll_function_value( &::SireCluster::Nodes::removeAll );
Nodes_exposer.def(
"removeAll"
, removeAll_function_value );
}
{ //::SireCluster::Nodes::toString
typedef ::QString ( ::SireCluster::Nodes::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireCluster::Nodes::toString );
Nodes_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireCluster::Nodes::waitUntilAllFree
typedef void ( ::SireCluster::Nodes::*waitUntilAllFree_function_type )( ) ;
waitUntilAllFree_function_type waitUntilAllFree_function_value( &::SireCluster::Nodes::waitUntilAllFree );
Nodes_exposer.def(
"waitUntilAllFree"
, waitUntilAllFree_function_value );
}
{ //::SireCluster::Nodes::waitUntilAllFree
typedef bool ( ::SireCluster::Nodes::*waitUntilAllFree_function_type )( int ) ;
waitUntilAllFree_function_type waitUntilAllFree_function_value( &::SireCluster::Nodes::waitUntilAllFree );
Nodes_exposer.def(
"waitUntilAllFree"
, waitUntilAllFree_function_value
, ( bp::arg("timeout") ) );
}
Nodes_exposer.def( "__copy__", &__copy__);
Nodes_exposer.def( "__deepcopy__", &__copy__);
Nodes_exposer.def( "clone", &__copy__);
Nodes_exposer.def( "__str__", &__str__< ::SireCluster::Nodes > );
Nodes_exposer.def( "__repr__", &__str__< ::SireCluster::Nodes > );
Nodes_exposer.def( "__len__", &__len_count< ::SireCluster::Nodes > );
}
}
void register_GridInfo_class(){
{ //::SireVol::GridInfo
typedef bp::class_< SireVol::GridInfo > GridInfo_exposer_t;
GridInfo_exposer_t GridInfo_exposer = GridInfo_exposer_t( "GridInfo", bp::init< >() );
bp::scope GridInfo_scope( GridInfo_exposer );
GridInfo_exposer.def( bp::init< SireVol::AABox const &, SireUnits::Dimension::Length >(( bp::arg("dimensions"), bp::arg("spacing") )) );
GridInfo_exposer.def( bp::init< SireVol::GridInfo const & >(( bp::arg("other") )) );
{ //::SireVol::GridInfo::arrayToGridIndex
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*arrayToGridIndex_function_type )( int ) const;
arrayToGridIndex_function_type arrayToGridIndex_function_value( &::SireVol::GridInfo::arrayToGridIndex );
GridInfo_exposer.def(
"arrayToGridIndex"
, arrayToGridIndex_function_value
, ( bp::arg("i") ) );
}
{ //::SireVol::GridInfo::at
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*at_function_type )( int ) const;
at_function_type at_function_value( &::SireVol::GridInfo::at );
GridInfo_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") ) );
}
{ //::SireVol::GridInfo::at
typedef int ( ::SireVol::GridInfo::*at_function_type )( ::SireVol::GridIndex const & ) const;
at_function_type at_function_value( &::SireVol::GridInfo::at );
GridInfo_exposer.def(
"at"
, at_function_value
, ( bp::arg("idx") ) );
}
{ //::SireVol::GridInfo::at
typedef int ( ::SireVol::GridInfo::*at_function_type )( int,int,int ) const;
at_function_type at_function_value( &::SireVol::GridInfo::at );
GridInfo_exposer.def(
"at"
, at_function_value
, ( bp::arg("i"), bp::arg("j"), bp::arg("k") ) );
}
{ //::SireVol::GridInfo::at
typedef int ( ::SireVol::GridInfo::*at_function_type )( ::SireMaths::Vector const & ) const;
at_function_type at_function_value( &::SireVol::GridInfo::at );
GridInfo_exposer.def(
"at"
, at_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::box
typedef ::SireVol::AABox ( ::SireVol::GridInfo::*box_function_type )( int ) const;
box_function_type box_function_value( &::SireVol::GridInfo::box );
GridInfo_exposer.def(
"box"
, box_function_value
, ( bp::arg("i") ) );
}
{ //::SireVol::GridInfo::box
typedef ::SireVol::AABox ( ::SireVol::GridInfo::*box_function_type )( ::SireVol::GridIndex const & ) const;
box_function_type box_function_value( &::SireVol::GridInfo::box );
GridInfo_exposer.def(
"box"
, box_function_value
, ( bp::arg("idx") ) );
}
{ //::SireVol::GridInfo::box
typedef ::SireVol::AABox ( ::SireVol::GridInfo::*box_function_type )( ::SireMaths::Vector const & ) const;
box_function_type box_function_value( &::SireVol::GridInfo::box );
GridInfo_exposer.def(
"box"
, box_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::closestIndexTo
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*closestIndexTo_function_type )( ::SireMaths::Vector const & ) const;
closestIndexTo_function_type closestIndexTo_function_value( &::SireVol::GridInfo::closestIndexTo );
GridInfo_exposer.def(
"closestIndexTo"
, closestIndexTo_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::contains
typedef bool ( ::SireVol::GridInfo::*contains_function_type )( ::SireMaths::Vector const & ) const;
contains_function_type contains_function_value( &::SireVol::GridInfo::contains );
GridInfo_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::count
typedef int ( ::SireVol::GridInfo::*count_function_type )( ) const;
count_function_type count_function_value( &::SireVol::GridInfo::count );
GridInfo_exposer.def(
"count"
, count_function_value );
}
{ //::SireVol::GridInfo::dimX
typedef ::qint32 ( ::SireVol::GridInfo::*dimX_function_type )( ) const;
dimX_function_type dimX_function_value( &::SireVol::GridInfo::dimX );
GridInfo_exposer.def(
"dimX"
, dimX_function_value );
}
{ //::SireVol::GridInfo::dimY
typedef ::qint32 ( ::SireVol::GridInfo::*dimY_function_type )( ) const;
dimY_function_type dimY_function_value( &::SireVol::GridInfo::dimY );
GridInfo_exposer.def(
"dimY"
, dimY_function_value );
}
{ //::SireVol::GridInfo::dimZ
typedef ::qint32 ( ::SireVol::GridInfo::*dimZ_function_type )( ) const;
dimZ_function_type dimZ_function_value( &::SireVol::GridInfo::dimZ );
GridInfo_exposer.def(
"dimZ"
, dimZ_function_value );
}
{ //::SireVol::GridInfo::dimensions
typedef ::SireVol::AABox ( ::SireVol::GridInfo::*dimensions_function_type )( ) const;
dimensions_function_type dimensions_function_value( &::SireVol::GridInfo::dimensions );
GridInfo_exposer.def(
"dimensions"
, dimensions_function_value );
}
{ //::SireVol::GridInfo::getitem
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*getitem_function_type )( int ) const;
getitem_function_type getitem_function_value( &::SireVol::GridInfo::getitem );
GridInfo_exposer.def(
"getitem"
, getitem_function_value
, ( bp::arg("i") ) );
}
{ //::SireVol::GridInfo::gridToArrayIndex
typedef int ( ::SireVol::GridInfo::*gridToArrayIndex_function_type )( int,int,int ) const;
gridToArrayIndex_function_type gridToArrayIndex_function_value( &::SireVol::GridInfo::gridToArrayIndex );
GridInfo_exposer.def(
"gridToArrayIndex"
, gridToArrayIndex_function_value
, ( bp::arg("i"), bp::arg("j"), bp::arg("k") ) );
}
{ //::SireVol::GridInfo::gridToArrayIndex
typedef int ( ::SireVol::GridInfo::*gridToArrayIndex_function_type )( ::SireVol::GridIndex const & ) const;
gridToArrayIndex_function_type gridToArrayIndex_function_value( &::SireVol::GridInfo::gridToArrayIndex );
GridInfo_exposer.def(
"gridToArrayIndex"
, gridToArrayIndex_function_value
, ( bp::arg("idx") ) );
}
{ //::SireVol::GridInfo::indexOf
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*indexOf_function_type )( int,::SireVol::GridInfo const & ) const;
indexOf_function_type indexOf_function_value( &::SireVol::GridInfo::indexOf );
GridInfo_exposer.def(
"indexOf"
, indexOf_function_value
, ( bp::arg("i"), bp::arg("grid") ) );
}
{ //::SireVol::GridInfo::indexOf
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*indexOf_function_type )( ::SireVol::GridIndex const &,::SireVol::GridInfo const & ) const;
indexOf_function_type indexOf_function_value( &::SireVol::GridInfo::indexOf );
GridInfo_exposer.def(
"indexOf"
, indexOf_function_value
, ( bp::arg("idx"), bp::arg("grid") ) );
}
{ //::SireVol::GridInfo::isEmpty
typedef bool ( ::SireVol::GridInfo::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireVol::GridInfo::isEmpty );
GridInfo_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireVol::GridInfo::nPoints
typedef int ( ::SireVol::GridInfo::*nPoints_function_type )( ) const;
nPoints_function_type nPoints_function_value( &::SireVol::GridInfo::nPoints );
GridInfo_exposer.def(
"nPoints"
, nPoints_function_value );
}
GridInfo_exposer.def( bp::self != bp::self );
{ //::SireVol::GridInfo::operator=
typedef ::SireVol::GridInfo & ( ::SireVol::GridInfo::*assign_function_type )( ::SireVol::GridInfo const & ) ;
assign_function_type assign_function_value( &::SireVol::GridInfo::operator= );
GridInfo_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
GridInfo_exposer.def( bp::self == bp::self );
{ //::SireVol::GridInfo::operator[]
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*__getitem___function_type )( int ) const;
__getitem___function_type __getitem___function_value( &::SireVol::GridInfo::operator[] );
GridInfo_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") ) );
}
{ //::SireVol::GridInfo::operator[]
typedef int ( ::SireVol::GridInfo::*__getitem___function_type )( ::SireVol::GridIndex const & ) const;
__getitem___function_type __getitem___function_value( &::SireVol::GridInfo::operator[] );
GridInfo_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("idx") ) );
}
{ //::SireVol::GridInfo::operator[]
typedef int ( ::SireVol::GridInfo::*__getitem___function_type )( ::SireMaths::Vector const & ) const;
__getitem___function_type __getitem___function_value( &::SireVol::GridInfo::operator[] );
GridInfo_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::point
typedef ::SireMaths::Vector ( ::SireVol::GridInfo::*point_function_type )( int ) const;
point_function_type point_function_value( &::SireVol::GridInfo::point );
GridInfo_exposer.def(
"point"
, point_function_value
, ( bp::arg("i") ) );
}
{ //::SireVol::GridInfo::point
typedef ::SireMaths::Vector ( ::SireVol::GridInfo::*point_function_type )( ::SireVol::GridIndex const & ) const;
point_function_type point_function_value( &::SireVol::GridInfo::point );
GridInfo_exposer.def(
"point"
, point_function_value
, ( bp::arg("idx") ) );
}
{ //::SireVol::GridInfo::point
typedef ::SireMaths::Vector ( ::SireVol::GridInfo::*point_function_type )( ::SireMaths::Vector const & ) const;
point_function_type point_function_value( &::SireVol::GridInfo::point );
GridInfo_exposer.def(
"point"
, point_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::pointToArrayIndex
typedef int ( ::SireVol::GridInfo::*pointToArrayIndex_function_type )( ::SireMaths::Vector const & ) const;
pointToArrayIndex_function_type pointToArrayIndex_function_value( &::SireVol::GridInfo::pointToArrayIndex );
GridInfo_exposer.def(
"pointToArrayIndex"
, pointToArrayIndex_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::pointToGridCorners
typedef void ( ::SireVol::GridInfo::*pointToGridCorners_function_type )( ::SireMaths::Vector const &,::QVector< int > & ) const;
pointToGridCorners_function_type pointToGridCorners_function_value( &::SireVol::GridInfo::pointToGridCorners );
GridInfo_exposer.def(
"pointToGridCorners"
, pointToGridCorners_function_value
, ( bp::arg("point"), bp::arg("indicies") ) );
}
{ //::SireVol::GridInfo::pointToGridCorners
typedef void ( ::SireVol::GridInfo::*pointToGridCorners_function_type )( ::SireMaths::Vector const &,::QVector< int > &,::QVector< float > & ) const;
pointToGridCorners_function_type pointToGridCorners_function_value( &::SireVol::GridInfo::pointToGridCorners );
GridInfo_exposer.def(
"pointToGridCorners"
, pointToGridCorners_function_value
, ( bp::arg("point"), bp::arg("indicies"), bp::arg("weights") ) );
}
{ //::SireVol::GridInfo::pointToGridCorners
typedef int ( ::SireVol::GridInfo::*pointToGridCorners_function_type )( ::SireMaths::MultiFloat const &,::SireMaths::MultiFloat const &,::SireMaths::MultiFloat const &,::QVector< SireMaths::MultiInt > & ) const;
pointToGridCorners_function_type pointToGridCorners_function_value( &::SireVol::GridInfo::pointToGridCorners );
GridInfo_exposer.def(
"pointToGridCorners"
, pointToGridCorners_function_value
, ( bp::arg("x"), bp::arg("y"), bp::arg("z"), bp::arg("indicies") ) );
}
{ //::SireVol::GridInfo::pointToGridCorners
typedef int ( ::SireVol::GridInfo::*pointToGridCorners_function_type )( ::SireMaths::MultiFloat const &,::SireMaths::MultiFloat const &,::SireMaths::MultiFloat const &,::QVector< SireMaths::MultiInt > &,::QVector< SireMaths::MultiFloat > & ) const;
pointToGridCorners_function_type pointToGridCorners_function_value( &::SireVol::GridInfo::pointToGridCorners );
GridInfo_exposer.def(
"pointToGridCorners"
, pointToGridCorners_function_value
, ( bp::arg("x"), bp::arg("y"), bp::arg("z"), bp::arg("indicies"), bp::arg("weights") ) );
}
{ //::SireVol::GridInfo::pointToGridIndex
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*pointToGridIndex_function_type )( ::SireMaths::Vector const & ) const;
pointToGridIndex_function_type pointToGridIndex_function_value( &::SireVol::GridInfo::pointToGridIndex );
GridInfo_exposer.def(
"pointToGridIndex"
, pointToGridIndex_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::redimension
typedef ::QVector< float > ( ::SireVol::GridInfo::*redimension_function_type )( ::QVector< float > const &,::SireVol::GridInfo const & ) const;
redimension_function_type redimension_function_value( &::SireVol::GridInfo::redimension );
GridInfo_exposer.def(
"redimension"
, redimension_function_value
, ( bp::arg("values"), bp::arg("new_grid") ) );
}
{ //::SireVol::GridInfo::size
typedef int ( ::SireVol::GridInfo::*size_function_type )( ) const;
size_function_type size_function_value( &::SireVol::GridInfo::size );
GridInfo_exposer.def(
"size"
, size_function_value );
}
{ //::SireVol::GridInfo::spacing
typedef ::SireUnits::Dimension::Length ( ::SireVol::GridInfo::*spacing_function_type )( ) const;
spacing_function_type spacing_function_value( &::SireVol::GridInfo::spacing );
GridInfo_exposer.def(
"spacing"
, spacing_function_value );
}
{ //::SireVol::GridInfo::toString
typedef ::QString ( ::SireVol::GridInfo::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireVol::GridInfo::toString );
GridInfo_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireVol::GridInfo::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireVol::GridInfo::typeName );
GridInfo_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireVol::GridInfo::what
typedef char const * ( ::SireVol::GridInfo::*what_function_type )( ) const;
what_function_type what_function_value( &::SireVol::GridInfo::what );
GridInfo_exposer.def(
"what"
, what_function_value );
}
GridInfo_exposer.staticmethod( "typeName" );
GridInfo_exposer.def( "__copy__", &__copy__);
GridInfo_exposer.def( "__deepcopy__", &__copy__);
GridInfo_exposer.def( "clone", &__copy__);
GridInfo_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::GridInfo >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
GridInfo_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::GridInfo >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
GridInfo_exposer.def( "__str__", &__str__< ::SireVol::GridInfo > );
GridInfo_exposer.def( "__repr__", &__str__< ::SireVol::GridInfo > );
GridInfo_exposer.def( "__len__", &__len_size< ::SireVol::GridInfo > );
GridInfo_exposer.def( "__getitem__", &::SireVol::GridInfo::getitem );
}
}
void register_PackedArray2D_int_Array_class(){
{ //::SireBase::detail::PackedArray2D_Array< int >
typedef bp::class_< SireBase::detail::PackedArray2D_Array< int > > PackedArray2D_int_Array_exposer_t;
PackedArray2D_int_Array_exposer_t PackedArray2D_int_Array_exposer = PackedArray2D_int_Array_exposer_t( "PackedArray2D_int_Array", bp::init< >() );
bp::scope PackedArray2D_int_Array_scope( PackedArray2D_int_Array_exposer );
PackedArray2D_int_Array_exposer.def( bp::init< quint32 >(( bp::arg("sz") )) );
PackedArray2D_int_Array_exposer.def( bp::init< quint32, int const & >(( bp::arg("sz"), bp::arg("value") )) );
PackedArray2D_int_Array_exposer.def( bp::init< QVector< int > const & >(( bp::arg("values") )) );
PackedArray2D_int_Array_exposer.def( bp::init< SireBase::detail::PackedArray2D_Array< int > const & >(( bp::arg("other") )) );
{ //::SireBase::detail::PackedArray2D_Array< int >::assertValidIndex
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef void ( ::SireBase::detail::PackedArray2D_Array< int >::*assertValidIndex_function_type )( ::quint32 ) const;
assertValidIndex_function_type assertValidIndex_function_value( &::SireBase::detail::PackedArray2D_Array< int >::assertValidIndex );
PackedArray2D_int_Array_exposer.def(
"assertValidIndex"
, assertValidIndex_function_value
, ( bp::arg("i") ) );
}
{ //::SireBase::detail::PackedArray2D_Array< int >::at
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef int const & ( ::SireBase::detail::PackedArray2D_Array< int >::*at_function_type )( ::quint32 ) const;
at_function_type at_function_value( &::SireBase::detail::PackedArray2D_Array< int >::at );
PackedArray2D_int_Array_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireBase::detail::PackedArray2D_Array< int >::count
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef int ( ::SireBase::detail::PackedArray2D_Array< int >::*count_function_type )( ) const;
count_function_type count_function_value( &::SireBase::detail::PackedArray2D_Array< int >::count );
PackedArray2D_int_Array_exposer.def(
"count"
, count_function_value );
}
{ //::SireBase::detail::PackedArray2D_Array< int >::isEmpty
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef bool ( ::SireBase::detail::PackedArray2D_Array< int >::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireBase::detail::PackedArray2D_Array< int >::isEmpty );
PackedArray2D_int_Array_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireBase::detail::PackedArray2D_Array< int >::nValues
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef int ( ::SireBase::detail::PackedArray2D_Array< int >::*nValues_function_type )( ) const;
nValues_function_type nValues_function_value( &::SireBase::detail::PackedArray2D_Array< int >::nValues );
PackedArray2D_int_Array_exposer.def(
"nValues"
, nValues_function_value );
}
PackedArray2D_int_Array_exposer.def( bp::self != bp::self );
{ //::SireBase::detail::PackedArray2D_Array< int >::operator=
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef ::SireBase::detail::PackedArray2D_Array< int > & ( ::SireBase::detail::PackedArray2D_Array< int >::*assign_function_type )( ::SireBase::detail::PackedArray2D_Array< int > const & ) ;
assign_function_type assign_function_value( &::SireBase::detail::PackedArray2D_Array< int >::operator= );
PackedArray2D_int_Array_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
PackedArray2D_int_Array_exposer.def( bp::self == bp::self );
{ //::SireBase::detail::PackedArray2D_Array< int >::operator[]
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef int const & ( ::SireBase::detail::PackedArray2D_Array< int >::*__getitem___function_type )( ::quint32 ) const;
__getitem___function_type __getitem___function_value( &::SireBase::detail::PackedArray2D_Array< int >::operator[] );
PackedArray2D_int_Array_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireBase::detail::PackedArray2D_Array< int >::operator[]
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef int & ( ::SireBase::detail::PackedArray2D_Array< int >::*__getitem___function_type )( ::quint32 ) ;
__getitem___function_type __getitem___function_value( &::SireBase::detail::PackedArray2D_Array< int >::operator[] );
PackedArray2D_int_Array_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_non_const_reference >() );
}
{ //::SireBase::detail::PackedArray2D_Array< int >::size
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef int ( ::SireBase::detail::PackedArray2D_Array< int >::*size_function_type )( ) const;
size_function_type size_function_value( &::SireBase::detail::PackedArray2D_Array< int >::size );
PackedArray2D_int_Array_exposer.def(
"size"
, size_function_value );
}
{ //::SireBase::detail::PackedArray2D_Array< int >::toQVector
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef ::QVector< int > ( ::SireBase::detail::PackedArray2D_Array< int >::*toQVector_function_type )( ) const;
toQVector_function_type toQVector_function_value( &::SireBase::detail::PackedArray2D_Array< int >::toQVector );
PackedArray2D_int_Array_exposer.def(
"toQVector"
, toQVector_function_value );
}
{ //::SireBase::detail::PackedArray2D_Array< int >::toString
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef ::QString ( ::SireBase::detail::PackedArray2D_Array< int >::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireBase::detail::PackedArray2D_Array< int >::toString );
PackedArray2D_int_Array_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireBase::detail::PackedArray2D_Array< int >::update
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef void ( ::SireBase::detail::PackedArray2D_Array< int >::*update_function_type )( ::SireBase::detail::PackedArray2D_Array< int > const & ) ;
update_function_type update_function_value( &::SireBase::detail::PackedArray2D_Array< int >::update );
PackedArray2D_int_Array_exposer.def(
"update"
, update_function_value
, ( bp::arg("other") ) );
}
PackedArray2D_int_Array_exposer.def( "__copy__", &__copy__);
PackedArray2D_int_Array_exposer.def( "__deepcopy__", &__copy__);
PackedArray2D_int_Array_exposer.def( "clone", &__copy__);
PackedArray2D_int_Array_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::detail::PackedArray2D_Array<int> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
PackedArray2D_int_Array_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::detail::PackedArray2D_Array<int> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
PackedArray2D_int_Array_exposer.def( "__str__", &__str__< ::SireBase::detail::PackedArray2D_Array<int> > );
PackedArray2D_int_Array_exposer.def( "__repr__", &__str__< ::SireBase::detail::PackedArray2D_Array<int> > );
PackedArray2D_int_Array_exposer.def( "__len__", &__len_size< ::SireBase::detail::PackedArray2D_Array<int> > );
}
}
void register_SupraSubMove_class(){
{ //::SireMove::SupraSubMove
typedef bp::class_< SireMove::SupraSubMove, bp::bases< SireBase::Property >, boost::noncopyable > SupraSubMove_exposer_t;
SupraSubMove_exposer_t SupraSubMove_exposer = SupraSubMove_exposer_t( "SupraSubMove", bp::no_init );
bp::scope SupraSubMove_scope( SupraSubMove_exposer );
{ //::SireMove::SupraSubMove::clearStatistics
typedef void ( ::SireMove::SupraSubMove::*clearStatistics_function_type )( ) ;
clearStatistics_function_type clearStatistics_function_value( &::SireMove::SupraSubMove::clearStatistics );
SupraSubMove_exposer.def(
"clearStatistics"
, clearStatistics_function_value );
}
{ //::SireMove::SupraSubMove::move
typedef void ( ::SireMove::SupraSubMove::*move_function_type )( ::SireMove::SupraSubSystem &,int,int,bool ) ;
move_function_type move_function_value( &::SireMove::SupraSubMove::move );
SupraSubMove_exposer.def(
"move"
, move_function_value
, ( bp::arg("system"), bp::arg("n_supra_moves"), bp::arg("n_supra_moves_per_block"), bp::arg("record_stats")=(bool)(true) ) );
}
{ //::SireMove::SupraSubMove::null
typedef ::SireMove::NullSupraSubMove const & ( *null_function_type )( );
null_function_type null_function_value( &::SireMove::SupraSubMove::null );
SupraSubMove_exposer.def(
"null"
, null_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMove::SupraSubMove::toString
typedef ::QString ( ::SireMove::SupraSubMove::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMove::SupraSubMove::toString );
SupraSubMove_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMove::SupraSubMove::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMove::SupraSubMove::typeName );
SupraSubMove_exposer.def(
"typeName"
, typeName_function_value );
}
SupraSubMove_exposer.staticmethod( "null" );
SupraSubMove_exposer.staticmethod( "typeName" );
SupraSubMove_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMove::SupraSubMove >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
SupraSubMove_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMove::SupraSubMove >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
SupraSubMove_exposer.def( "__str__", &__str__< ::SireMove::SupraSubMove > );
SupraSubMove_exposer.def( "__repr__", &__str__< ::SireMove::SupraSubMove > );
}
}
void register_DataPoint_class(){
{ //::SireAnalysis::DataPoint
typedef bp::class_< SireAnalysis::DataPoint > DataPoint_exposer_t;
DataPoint_exposer_t DataPoint_exposer = DataPoint_exposer_t( "DataPoint", "This class represents a single datapoint on an x,y graph. The point\nhas associated errors (small and large) on both the x and y axes\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor. This constructs the point (0,0) with no error") );
bp::scope DataPoint_scope( DataPoint_exposer );
DataPoint_exposer.def( bp::init< double, double >(( bp::arg("x"), bp::arg("y") ), "Construct the point (x,y) with no error") );
DataPoint_exposer.def( bp::init< double, double, double, double >(( bp::arg("x"), bp::arg("y"), bp::arg("xerror"), bp::arg("yerror") ), "Construct the point (x,y) with error (xerror,yerror)") );
DataPoint_exposer.def( bp::init< double, double, double, double, double, double >(( bp::arg("x"), bp::arg("y"), bp::arg("xminerror"), bp::arg("yminerror"), bp::arg("xmaxerror"), bp::arg("ymaxerror") ), "Construct the point (x,y) with a minimum error of (xminerror,yminerror)\nand a maximum error of (xmaxerror,ymaxerror). This is for situations where\nthere may be multiple different error measures on a point and you want\nto store the range of errors (based on a range of error estimates)") );
DataPoint_exposer.def( bp::init< SireAnalysis::DataPoint const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireAnalysis::DataPoint::equalWithinError
typedef bool ( ::SireAnalysis::DataPoint::*equalWithinError_function_type)( ::SireAnalysis::DataPoint const & ) const;
equalWithinError_function_type equalWithinError_function_value( &::SireAnalysis::DataPoint::equalWithinError );
DataPoint_exposer.def(
"equalWithinError"
, equalWithinError_function_value
, ( bp::arg("other") )
, "Return whether or not this data point is equal to the other, within\nthe error range of the two points" );
}
{ //::SireAnalysis::DataPoint::equalWithinMaxError
typedef bool ( ::SireAnalysis::DataPoint::*equalWithinMaxError_function_type)( ::SireAnalysis::DataPoint const & ) const;
equalWithinMaxError_function_type equalWithinMaxError_function_value( &::SireAnalysis::DataPoint::equalWithinMaxError );
DataPoint_exposer.def(
"equalWithinMaxError"
, equalWithinMaxError_function_value
, ( bp::arg("other") )
, "Return whether or not this data point in equal to the other, within\nthe maximum error range of the two points" );
}
{ //::SireAnalysis::DataPoint::equalWithinMinError
typedef bool ( ::SireAnalysis::DataPoint::*equalWithinMinError_function_type)( ::SireAnalysis::DataPoint const & ) const;
equalWithinMinError_function_type equalWithinMinError_function_value( &::SireAnalysis::DataPoint::equalWithinMinError );
DataPoint_exposer.def(
"equalWithinMinError"
, equalWithinMinError_function_value
, ( bp::arg("other") )
, "Return whether or not this data point in equal to the other, within\nthe minimum error range of the two points" );
}
{ //::SireAnalysis::DataPoint::hasError
typedef bool ( ::SireAnalysis::DataPoint::*hasError_function_type)( ) const;
hasError_function_type hasError_function_value( &::SireAnalysis::DataPoint::hasError );
DataPoint_exposer.def(
"hasError"
, hasError_function_value
, "Return whether or not this data point has any error" );
}
{ //::SireAnalysis::DataPoint::hasErrorRange
typedef bool ( ::SireAnalysis::DataPoint::*hasErrorRange_function_type)( ) const;
hasErrorRange_function_type hasErrorRange_function_value( &::SireAnalysis::DataPoint::hasErrorRange );
DataPoint_exposer.def(
"hasErrorRange"
, hasErrorRange_function_value
, "Return whether or not this data point has an error range" );
}
{ //::SireAnalysis::DataPoint::hasXError
typedef bool ( ::SireAnalysis::DataPoint::*hasXError_function_type)( ) const;
hasXError_function_type hasXError_function_value( &::SireAnalysis::DataPoint::hasXError );
DataPoint_exposer.def(
"hasXError"
, hasXError_function_value
, "Return whether or not there is any error in the x value" );
}
{ //::SireAnalysis::DataPoint::hasXErrorRange
typedef bool ( ::SireAnalysis::DataPoint::*hasXErrorRange_function_type)( ) const;
hasXErrorRange_function_type hasXErrorRange_function_value( &::SireAnalysis::DataPoint::hasXErrorRange );
DataPoint_exposer.def(
"hasXErrorRange"
, hasXErrorRange_function_value
, "Return whether or not there is an error range on the x value" );
}
{ //::SireAnalysis::DataPoint::hasYError
typedef bool ( ::SireAnalysis::DataPoint::*hasYError_function_type)( ) const;
hasYError_function_type hasYError_function_value( &::SireAnalysis::DataPoint::hasYError );
DataPoint_exposer.def(
"hasYError"
, hasYError_function_value
, "Return whether or not there is any error in the y value" );
}
{ //::SireAnalysis::DataPoint::hasYErrorRange
typedef bool ( ::SireAnalysis::DataPoint::*hasYErrorRange_function_type)( ) const;
hasYErrorRange_function_type hasYErrorRange_function_value( &::SireAnalysis::DataPoint::hasYErrorRange );
DataPoint_exposer.def(
"hasYErrorRange"
, hasYErrorRange_function_value
, "Return whether or not there is an error range on the x value" );
}
DataPoint_exposer.def( bp::self != bp::self );
{ //::SireAnalysis::DataPoint::operator=
typedef ::SireAnalysis::DataPoint & ( ::SireAnalysis::DataPoint::*assign_function_type)( ::SireAnalysis::DataPoint const & ) ;
assign_function_type assign_function_value( &::SireAnalysis::DataPoint::operator= );
DataPoint_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
DataPoint_exposer.def( bp::self == bp::self );
{ //::SireAnalysis::DataPoint::toString
typedef ::QString ( ::SireAnalysis::DataPoint::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireAnalysis::DataPoint::toString );
DataPoint_exposer.def(
"toString"
, toString_function_value
, "" );
}
{ //::SireAnalysis::DataPoint::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireAnalysis::DataPoint::typeName );
DataPoint_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireAnalysis::DataPoint::what
typedef char const * ( ::SireAnalysis::DataPoint::*what_function_type)( ) const;
what_function_type what_function_value( &::SireAnalysis::DataPoint::what );
DataPoint_exposer.def(
"what"
, what_function_value
, "" );
}
{ //::SireAnalysis::DataPoint::x
typedef double ( ::SireAnalysis::DataPoint::*x_function_type)( ) const;
x_function_type x_function_value( &::SireAnalysis::DataPoint::x );
DataPoint_exposer.def(
"x"
, x_function_value
, "Return the x value of the point" );
}
{ //::SireAnalysis::DataPoint::xError
typedef double ( ::SireAnalysis::DataPoint::*xError_function_type)( ) const;
xError_function_type xError_function_value( &::SireAnalysis::DataPoint::xError );
DataPoint_exposer.def(
"xError"
, xError_function_value
, "Return the error on the x value. This is the average\nof the minimum and maximum error" );
}
{ //::SireAnalysis::DataPoint::xMaxError
typedef double ( ::SireAnalysis::DataPoint::*xMaxError_function_type)( ) const;
xMaxError_function_type xMaxError_function_value( &::SireAnalysis::DataPoint::xMaxError );
DataPoint_exposer.def(
"xMaxError"
, xMaxError_function_value
, "Return the maximum size of the error on the x value" );
}
{ //::SireAnalysis::DataPoint::xMinError
typedef double ( ::SireAnalysis::DataPoint::*xMinError_function_type)( ) const;
xMinError_function_type xMinError_function_value( &::SireAnalysis::DataPoint::xMinError );
DataPoint_exposer.def(
"xMinError"
, xMinError_function_value
, "Return the minimum size of the error on the x value" );
}
{ //::SireAnalysis::DataPoint::y
typedef double ( ::SireAnalysis::DataPoint::*y_function_type)( ) const;
y_function_type y_function_value( &::SireAnalysis::DataPoint::y );
DataPoint_exposer.def(
"y"
, y_function_value
, "Return the y value of the point" );
}
{ //::SireAnalysis::DataPoint::yError
typedef double ( ::SireAnalysis::DataPoint::*yError_function_type)( ) const;
yError_function_type yError_function_value( &::SireAnalysis::DataPoint::yError );
DataPoint_exposer.def(
"yError"
, yError_function_value
, "Return the error on the y value. This is the average\nof the minimum and maximum error" );
}
{ //::SireAnalysis::DataPoint::yMaxError
typedef double ( ::SireAnalysis::DataPoint::*yMaxError_function_type)( ) const;
yMaxError_function_type yMaxError_function_value( &::SireAnalysis::DataPoint::yMaxError );
DataPoint_exposer.def(
"yMaxError"
, yMaxError_function_value
, "Return the maximum size of the error on the y value" );
}
{ //::SireAnalysis::DataPoint::yMinError
typedef double ( ::SireAnalysis::DataPoint::*yMinError_function_type)( ) const;
yMinError_function_type yMinError_function_value( &::SireAnalysis::DataPoint::yMinError );
DataPoint_exposer.def(
"yMinError"
, yMinError_function_value
, "Return the minimum size of the error on the y value" );
}
DataPoint_exposer.staticmethod( "typeName" );
DataPoint_exposer.def( "__copy__", &__copy__);
DataPoint_exposer.def( "__deepcopy__", &__copy__);
DataPoint_exposer.def( "clone", &__copy__);
DataPoint_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireAnalysis::DataPoint >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
DataPoint_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireAnalysis::DataPoint >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
DataPoint_exposer.def( "__str__", &__str__< ::SireAnalysis::DataPoint > );
DataPoint_exposer.def( "__repr__", &__str__< ::SireAnalysis::DataPoint > );
}
}
void register_CLJAtom_class(){
{ //::SireMM::CLJAtom
typedef bp::class_< SireMM::CLJAtom > CLJAtom_exposer_t;
CLJAtom_exposer_t CLJAtom_exposer = CLJAtom_exposer_t( "CLJAtom", bp::init< >() );
bp::scope CLJAtom_scope( CLJAtom_exposer );
CLJAtom_exposer.def( bp::init< SireMaths::Vector, SireUnits::Dimension::Charge, SireMM::LJParameter, bp::optional< qint32 > >(( bp::arg("coords"), bp::arg("charge"), bp::arg("ljparam"), bp::arg("idnum")=(int)(1) )) );
CLJAtom_exposer.def( bp::init< SireMM::CLJAtom const & >(( bp::arg("other") )) );
{ //::SireMM::CLJAtom::ID
typedef ::qint32 ( ::SireMM::CLJAtom::*ID_function_type )( ) const;
ID_function_type ID_function_value( &::SireMM::CLJAtom::ID );
CLJAtom_exposer.def(
"ID"
, ID_function_value );
}
{ //::SireMM::CLJAtom::buildFrom
typedef ::QVector< SireMM::CLJAtom > ( *buildFrom_function_type )( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & );
buildFrom_function_type buildFrom_function_value( &::SireMM::CLJAtom::buildFrom );
CLJAtom_exposer.def(
"buildFrom"
, buildFrom_function_value
, ( bp::arg("molecule"), bp::arg("map")=SireBase::PropertyMap() ) );
}
{ //::SireMM::CLJAtom::charge
typedef ::SireUnits::Dimension::Charge ( ::SireMM::CLJAtom::*charge_function_type )( ) const;
charge_function_type charge_function_value( &::SireMM::CLJAtom::charge );
CLJAtom_exposer.def(
"charge"
, charge_function_value );
}
{ //::SireMM::CLJAtom::coordinates
typedef ::SireMaths::Vector ( ::SireMM::CLJAtom::*coordinates_function_type )( ) const;
coordinates_function_type coordinates_function_value( &::SireMM::CLJAtom::coordinates );
CLJAtom_exposer.def(
"coordinates"
, coordinates_function_value );
}
{ //::SireMM::CLJAtom::isDummy
typedef bool ( ::SireMM::CLJAtom::*isDummy_function_type )( ) const;
isDummy_function_type isDummy_function_value( &::SireMM::CLJAtom::isDummy );
CLJAtom_exposer.def(
"isDummy"
, isDummy_function_value );
}
{ //::SireMM::CLJAtom::isNull
typedef bool ( ::SireMM::CLJAtom::*isNull_function_type )( ) const;
isNull_function_type isNull_function_value( &::SireMM::CLJAtom::isNull );
CLJAtom_exposer.def(
"isNull"
, isNull_function_value );
}
{ //::SireMM::CLJAtom::ljParameter
typedef ::SireMM::LJParameter ( ::SireMM::CLJAtom::*ljParameter_function_type )( ) const;
ljParameter_function_type ljParameter_function_value( &::SireMM::CLJAtom::ljParameter );
CLJAtom_exposer.def(
"ljParameter"
, ljParameter_function_value );
}
{ //::SireMM::CLJAtom::negate
typedef ::SireMM::CLJAtom ( ::SireMM::CLJAtom::*negate_function_type )( ) const;
negate_function_type negate_function_value( &::SireMM::CLJAtom::negate );
CLJAtom_exposer.def(
"negate"
, negate_function_value );
}
CLJAtom_exposer.def( bp::self != bp::self );
{ //::SireMM::CLJAtom::operator=
typedef ::SireMM::CLJAtom & ( ::SireMM::CLJAtom::*assign_function_type )( ::SireMM::CLJAtom const & ) ;
assign_function_type assign_function_value( &::SireMM::CLJAtom::operator= );
CLJAtom_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
CLJAtom_exposer.def( bp::self == bp::self );
{ //::SireMM::CLJAtom::toString
typedef ::QString ( ::SireMM::CLJAtom::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMM::CLJAtom::toString );
CLJAtom_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMM::CLJAtom::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMM::CLJAtom::typeName );
CLJAtom_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMM::CLJAtom::what
typedef char const * ( ::SireMM::CLJAtom::*what_function_type )( ) const;
what_function_type what_function_value( &::SireMM::CLJAtom::what );
CLJAtom_exposer.def(
"what"
, what_function_value );
}
CLJAtom_exposer.staticmethod( "buildFrom" );
CLJAtom_exposer.staticmethod( "typeName" );
CLJAtom_exposer.def( "__copy__", &__copy__);
CLJAtom_exposer.def( "__deepcopy__", &__copy__);
CLJAtom_exposer.def( "clone", &__copy__);
CLJAtom_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::CLJAtom >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CLJAtom_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::CLJAtom >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CLJAtom_exposer.def( "__str__", &__str__< ::SireMM::CLJAtom > );
CLJAtom_exposer.def( "__repr__", &__str__< ::SireMM::CLJAtom > );
}
}
void register_MolResNum_class(){
{ //::SireMol::MolResNum
typedef bp::class_< SireMol::MolResNum, bp::bases< SireMol::ResID, SireID::ID > > MolResNum_exposer_t;
MolResNum_exposer_t MolResNum_exposer = MolResNum_exposer_t( "MolResNum", bp::init< >() );
bp::scope MolResNum_scope( MolResNum_exposer );
MolResNum_exposer.def( bp::init< SireMol::MolNum const &, SireMol::ResNum const & >(( bp::arg("molnum"), bp::arg("resnum") )) );
MolResNum_exposer.def( bp::init< SireMol::ResNum const &, SireMol::MolNum const & >(( bp::arg("resnum"), bp::arg("molnum") )) );
MolResNum_exposer.def( bp::init< SireMol::MolResNum const & >(( bp::arg("other") )) );
{ //::SireMol::MolResNum::hash
typedef ::uint ( ::SireMol::MolResNum::*hash_function_type )( ) const;
hash_function_type hash_function_value( &::SireMol::MolResNum::hash );
MolResNum_exposer.def(
"hash"
, hash_function_value );
}
{ //::SireMol::MolResNum::isNull
typedef bool ( ::SireMol::MolResNum::*isNull_function_type )( ) const;
isNull_function_type isNull_function_value( &::SireMol::MolResNum::isNull );
MolResNum_exposer.def(
"isNull"
, isNull_function_value );
}
{ //::SireMol::MolResNum::map
typedef ::QList< SireMol::ResIdx > ( ::SireMol::MolResNum::*map_function_type )( ::SireMol::MolInfo const & ) const;
map_function_type map_function_value( &::SireMol::MolResNum::map );
MolResNum_exposer.def(
"map"
, map_function_value
, ( bp::arg("molinfo") ) );
}
{ //::SireMol::MolResNum::molNum
typedef ::SireMol::MolNum const & ( ::SireMol::MolResNum::*molNum_function_type )( ) const;
molNum_function_type molNum_function_value( &::SireMol::MolResNum::molNum );
MolResNum_exposer.def(
"molNum"
, molNum_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
MolResNum_exposer.def( bp::self != bp::self );
{ //::SireMol::MolResNum::operator=
typedef ::SireMol::MolResNum & ( ::SireMol::MolResNum::*assign_function_type )( ::SireMol::MolResNum const & ) ;
assign_function_type assign_function_value( &::SireMol::MolResNum::operator= );
MolResNum_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
MolResNum_exposer.def( bp::self == bp::other< SireID::ID >() );
MolResNum_exposer.def( bp::self == bp::self );
{ //::SireMol::MolResNum::resNum
typedef ::SireMol::ResNum const & ( ::SireMol::MolResNum::*resNum_function_type )( ) const;
resNum_function_type resNum_function_value( &::SireMol::MolResNum::resNum );
MolResNum_exposer.def(
"resNum"
, resNum_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::MolResNum::selectAllFrom
typedef ::QHash< SireMol::MolNum, SireMol::Selector< SireMol::Residue > > ( ::SireMol::MolResNum::*selectAllFrom_function_type )( ::SireMol::Molecules const &,::SireBase::PropertyMap const & ) const;
selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::MolResNum::selectAllFrom );
MolResNum_exposer.def(
"selectAllFrom"
, selectAllFrom_function_value
, ( bp::arg("molecules"), bp::arg("map")=SireBase::PropertyMap() ) );
}
{ //::SireMol::MolResNum::selectAllFrom
typedef ::QHash< SireMol::MolNum, SireMol::Selector< SireMol::Residue > > ( ::SireMol::MolResNum::*selectAllFrom_function_type )( ::SireMol::MoleculeGroup const &,::SireBase::PropertyMap const & ) const;
selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::MolResNum::selectAllFrom );
MolResNum_exposer.def(
"selectAllFrom"
, selectAllFrom_function_value
, ( bp::arg("molgroup"), bp::arg("map")=SireBase::PropertyMap() ) );
}
{ //::SireMol::MolResNum::selectAllFrom
typedef ::QHash< SireMol::MolNum, SireMol::Selector< SireMol::Residue > > ( ::SireMol::MolResNum::*selectAllFrom_function_type )( ::SireMol::MolGroupsBase const &,::SireBase::PropertyMap const & ) const;
selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::MolResNum::selectAllFrom );
MolResNum_exposer.def(
"selectAllFrom"
, selectAllFrom_function_value
, ( bp::arg("molgroups"), bp::arg("map")=SireBase::PropertyMap() ) );
}
{ //::SireMol::MolResNum::toString
typedef ::QString ( ::SireMol::MolResNum::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMol::MolResNum::toString );
MolResNum_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMol::MolResNum::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::MolResNum::typeName );
MolResNum_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMol::MolResNum::what
typedef char const * ( ::SireMol::MolResNum::*what_function_type )( ) const;
what_function_type what_function_value( &::SireMol::MolResNum::what );
MolResNum_exposer.def(
"what"
, what_function_value );
}
MolResNum_exposer.staticmethod( "typeName" );
MolResNum_exposer.def( "__copy__", &__copy__);
MolResNum_exposer.def( "__deepcopy__", &__copy__);
MolResNum_exposer.def( "clone", &__copy__);
MolResNum_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::MolResNum >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
MolResNum_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::MolResNum >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
MolResNum_exposer.def( "__str__", &__str__< ::SireMol::MolResNum > );
MolResNum_exposer.def( "__repr__", &__str__< ::SireMol::MolResNum > );
}
}
void register_AngleComponent_class(){
{ //::SireSystem::AngleComponent
typedef bp::class_< SireSystem::AngleComponent, bp::bases< SireSystem::GeometryComponent, SireSystem::Constraint, SireBase::Property > > AngleComponent_exposer_t;
AngleComponent_exposer_t AngleComponent_exposer = AngleComponent_exposer_t( "AngleComponent", "This is a constraint that constrains a symbol to equal the\nvalue of an expression that involves an angle between three points\nor atoms\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") );
bp::scope AngleComponent_scope( AngleComponent_exposer );
AngleComponent_exposer.def( bp::init< SireCAS::Symbol const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("constrained_symbol"), bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("map")=SireBase::PropertyMap() ), "Construct to set the value of constrained_symbol equal to the\nangle between the three points point0, point1 and point2") );
AngleComponent_exposer.def( bp::init< SireCAS::Symbol const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireCAS::Expression const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("constrained_symbol"), bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("geometry_expression"), bp::arg("map")=SireBase::PropertyMap() ), "Construct to set the value of constrained_symbol equal to the\nexpression based on the angles within the three points\npoint0, point1 and point2") );
AngleComponent_exposer.def( bp::init< SireSystem::AngleComponent const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireSystem::AngleComponent::nPoints
typedef int ( ::SireSystem::AngleComponent::*nPoints_function_type)( ) const;
nPoints_function_type nPoints_function_value( &::SireSystem::AngleComponent::nPoints );
AngleComponent_exposer.def(
"nPoints"
, nPoints_function_value
, "Return the number of points (3)" );
}
AngleComponent_exposer.def( bp::self != bp::self );
{ //::SireSystem::AngleComponent::operator=
typedef ::SireSystem::AngleComponent & ( ::SireSystem::AngleComponent::*assign_function_type)( ::SireSystem::AngleComponent const & ) ;
assign_function_type assign_function_value( &::SireSystem::AngleComponent::operator= );
AngleComponent_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
AngleComponent_exposer.def( bp::self == bp::self );
{ //::SireSystem::AngleComponent::point
typedef ::SireFF::Point const & ( ::SireSystem::AngleComponent::*point_function_type)( int ) const;
point_function_type point_function_value( &::SireSystem::AngleComponent::point );
AngleComponent_exposer.def(
"point"
, point_function_value
, ( bp::arg("i") )
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the ith point\nThrow: SireError::invalid_index\n" );
}
{ //::SireSystem::AngleComponent::point0
typedef ::SireFF::Point const & ( ::SireSystem::AngleComponent::*point0_function_type)( ) const;
point0_function_type point0_function_value( &::SireSystem::AngleComponent::point0 );
AngleComponent_exposer.def(
"point0"
, point0_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the first point between which the angle is calculated" );
}
{ //::SireSystem::AngleComponent::point1
typedef ::SireFF::Point const & ( ::SireSystem::AngleComponent::*point1_function_type)( ) const;
point1_function_type point1_function_value( &::SireSystem::AngleComponent::point1 );
AngleComponent_exposer.def(
"point1"
, point1_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the second point between which the angle is calculated" );
}
{ //::SireSystem::AngleComponent::point2
typedef ::SireFF::Point const & ( ::SireSystem::AngleComponent::*point2_function_type)( ) const;
point2_function_type point2_function_value( &::SireSystem::AngleComponent::point2 );
AngleComponent_exposer.def(
"point2"
, point2_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the third point between which the angle is calculated" );
}
{ //::SireSystem::AngleComponent::r01
typedef ::SireCAS::Symbol const & ( *r01_function_type )( );
r01_function_type r01_function_value( &::SireSystem::AngleComponent::r01 );
AngleComponent_exposer.def(
"r01"
, r01_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the symbol that represents the 0-1 distance" );
}
{ //::SireSystem::AngleComponent::r02
typedef ::SireCAS::Symbol const & ( *r02_function_type )( );
r02_function_type r02_function_value( &::SireSystem::AngleComponent::r02 );
AngleComponent_exposer.def(
"r02"
, r02_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the symbol that represents the 0-2 distance" );
}
{ //::SireSystem::AngleComponent::r12
typedef ::SireCAS::Symbol const & ( *r12_function_type )( );
r12_function_type r12_function_value( &::SireSystem::AngleComponent::r12 );
AngleComponent_exposer.def(
"r12"
, r12_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the symbol that represents the 1-2 distance" );
}
{ //::SireSystem::AngleComponent::theta
typedef ::SireCAS::Symbol const & ( *theta_function_type )( );
theta_function_type theta_function_value( &::SireSystem::AngleComponent::theta );
AngleComponent_exposer.def(
"theta"
, theta_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the symbol that represents the central angle between\nthe three points" );
}
{ //::SireSystem::AngleComponent::theta012
typedef ::SireCAS::Symbol const & ( *theta012_function_type )( );
theta012_function_type theta012_function_value( &::SireSystem::AngleComponent::theta012 );
AngleComponent_exposer.def(
"theta012"
, theta012_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the symbol that represents the angle 012 between\nthe three points" );
}
{ //::SireSystem::AngleComponent::theta021
typedef ::SireCAS::Symbol const & ( *theta021_function_type )( );
theta021_function_type theta021_function_value( &::SireSystem::AngleComponent::theta021 );
AngleComponent_exposer.def(
"theta021"
, theta021_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the symbol that represents the angle 021 between\nthe three points" );
}
{ //::SireSystem::AngleComponent::theta102
typedef ::SireCAS::Symbol const & ( *theta102_function_type )( );
theta102_function_type theta102_function_value( &::SireSystem::AngleComponent::theta102 );
AngleComponent_exposer.def(
"theta102"
, theta102_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the symbol that represents the angle 102 between\nthe three points" );
}
{ //::SireSystem::AngleComponent::toString
typedef ::QString ( ::SireSystem::AngleComponent::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireSystem::AngleComponent::toString );
AngleComponent_exposer.def(
"toString"
, toString_function_value
, "" );
}
{ //::SireSystem::AngleComponent::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireSystem::AngleComponent::typeName );
AngleComponent_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
AngleComponent_exposer.staticmethod( "r01" );
AngleComponent_exposer.staticmethod( "r02" );
AngleComponent_exposer.staticmethod( "r12" );
AngleComponent_exposer.staticmethod( "theta" );
AngleComponent_exposer.staticmethod( "theta012" );
AngleComponent_exposer.staticmethod( "theta021" );
AngleComponent_exposer.staticmethod( "theta102" );
AngleComponent_exposer.staticmethod( "typeName" );
AngleComponent_exposer.def( "__copy__", &__copy__);
AngleComponent_exposer.def( "__deepcopy__", &__copy__);
AngleComponent_exposer.def( "clone", &__copy__);
AngleComponent_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireSystem::AngleComponent >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
AngleComponent_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireSystem::AngleComponent >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
AngleComponent_exposer.def( "__str__", &__str__< ::SireSystem::AngleComponent > );
AngleComponent_exposer.def( "__repr__", &__str__< ::SireSystem::AngleComponent > );
}
}
void register_IDAssigner_class(){
{ //::SireSystem::IDAssigner
typedef bp::class_< SireSystem::IDAssigner, bp::bases< SireBase::Property > > IDAssigner_exposer_t;
IDAssigner_exposer_t IDAssigner_exposer = IDAssigner_exposer_t( "IDAssigner", "This class uses the machinery of the identity point to\npick out molecules that are associated with identity points.\nThis is useful if you want to monitor a property or energy,\nbut dont actually want to change the coordinates of atoms\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") );
bp::scope IDAssigner_scope( IDAssigner_exposer );
IDAssigner_exposer.def( bp::init< SireFF::PointRef const &, SireMol::MoleculeGroup const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("point"), bp::arg("molgroup"), bp::arg("map")=SireBase::PropertyMap() ), "Constructor") );
IDAssigner_exposer.def( bp::init< QVector< SireBase::PropPtr< SireFF::Point > > const &, SireMol::MoleculeGroup const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("points"), bp::arg("molgroup"), bp::arg("map")=SireBase::PropertyMap() ), "Construct to find the identity of the molecules from\nmolgroup that match the points in points -\nthis creates a list of n molecules, where the ith molecule\nis matched to the ith point") );
IDAssigner_exposer.def( bp::init< SireFF::PointRef const &, SireMol::MoleculeGroup const &, SireVol::Space const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("point"), bp::arg("molgroup"), bp::arg("space"), bp::arg("map")=SireBase::PropertyMap() ), "Constructor") );
IDAssigner_exposer.def( bp::init< QVector< SireBase::PropPtr< SireFF::Point > > const &, SireMol::MoleculeGroup const &, SireVol::Space const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("points"), bp::arg("molgroup"), bp::arg("space"), bp::arg("map")=SireBase::PropertyMap() ), "Construct to find the identity of the molecules from\nmolgroup that match the points in points -\nthis creates a list of n molecules, where the ith molecule\nis matched to the ith point") );
IDAssigner_exposer.def( bp::init< SireSystem::IDAssigner const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireSystem::IDAssigner::identifiedMolecules
typedef ::QVector< SireMol::PartialMolecule > ( ::SireSystem::IDAssigner::*identifiedMolecules_function_type)( ) const;
identifiedMolecules_function_type identifiedMolecules_function_value( &::SireSystem::IDAssigner::identifiedMolecules );
IDAssigner_exposer.def(
"identifiedMolecules"
, identifiedMolecules_function_value
, "Returns the list of identified molecules from the system,\nwhich are returned in the same order as the list of identity points\n" );
}
{ //::SireSystem::IDAssigner::moleculeGroup
typedef ::SireMol::MoleculeGroup const & ( ::SireSystem::IDAssigner::*moleculeGroup_function_type)( ) const;
moleculeGroup_function_type moleculeGroup_function_value( &::SireSystem::IDAssigner::moleculeGroup );
IDAssigner_exposer.def(
"moleculeGroup"
, moleculeGroup_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the molecule group operated on by this constraint" );
}
{ //::SireSystem::IDAssigner::nPoints
typedef int ( ::SireSystem::IDAssigner::*nPoints_function_type)( ) const;
nPoints_function_type nPoints_function_value( &::SireSystem::IDAssigner::nPoints );
IDAssigner_exposer.def(
"nPoints"
, nPoints_function_value
, "Return the number of identity points (and thus the number of\nidentified molecules)" );
}
IDAssigner_exposer.def( bp::self != bp::self );
{ //::SireSystem::IDAssigner::operator=
typedef ::SireSystem::IDAssigner & ( ::SireSystem::IDAssigner::*assign_function_type)( ::SireSystem::IDAssigner const & ) ;
assign_function_type assign_function_value( &::SireSystem::IDAssigner::operator= );
IDAssigner_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
IDAssigner_exposer.def( bp::self == bp::self );
{ //::SireSystem::IDAssigner::points
typedef ::QVector< SireBase::PropPtr< SireFF::Point > > ( ::SireSystem::IDAssigner::*points_function_type)( ) const;
points_function_type points_function_value( &::SireSystem::IDAssigner::points );
IDAssigner_exposer.def(
"points"
, points_function_value
, "Return the points used to identify the molecules" );
}
{ //::SireSystem::IDAssigner::propertyMap
typedef ::SireBase::PropertyMap const & ( ::SireSystem::IDAssigner::*propertyMap_function_type)( ) const;
propertyMap_function_type propertyMap_function_value( &::SireSystem::IDAssigner::propertyMap );
IDAssigner_exposer.def(
"propertyMap"
, propertyMap_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the property map used to find the properties required\nby this constraint" );
}
{ //::SireSystem::IDAssigner::space
typedef ::SireVol::Space const & ( ::SireSystem::IDAssigner::*space_function_type)( ) const;
space_function_type space_function_value( &::SireSystem::IDAssigner::space );
IDAssigner_exposer.def(
"space"
, space_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the space used to calculate distances between the molecules\nand the identity points" );
}
{ //::SireSystem::IDAssigner::toString
typedef ::QString ( ::SireSystem::IDAssigner::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireSystem::IDAssigner::toString );
IDAssigner_exposer.def(
"toString"
, toString_function_value
, "Return a string representation of this assigner" );
}
{ //::SireSystem::IDAssigner::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireSystem::IDAssigner::typeName );
IDAssigner_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireSystem::IDAssigner::update
typedef void ( ::SireSystem::IDAssigner::*update_function_type)( ::SireSystem::System const & ) ;
update_function_type update_function_value( &::SireSystem::IDAssigner::update );
IDAssigner_exposer.def(
"update"
, update_function_value
, ( bp::arg("system") )
, "Update the assigner with the passed system." );
}
{ //::SireSystem::IDAssigner::what
typedef char const * ( ::SireSystem::IDAssigner::*what_function_type)( ) const;
what_function_type what_function_value( &::SireSystem::IDAssigner::what );
IDAssigner_exposer.def(
"what"
, what_function_value
, "" );
}
IDAssigner_exposer.staticmethod( "typeName" );
IDAssigner_exposer.def( "__copy__", &__copy__);
IDAssigner_exposer.def( "__deepcopy__", &__copy__);
IDAssigner_exposer.def( "clone", &__copy__);
IDAssigner_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireSystem::IDAssigner >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
IDAssigner_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireSystem::IDAssigner >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
IDAssigner_exposer.def( "__str__", &__str__< ::SireSystem::IDAssigner > );
IDAssigner_exposer.def( "__repr__", &__str__< ::SireSystem::IDAssigner > );
}
}
void register_QDate_class(){
{ //::QDate
typedef bp::class_< QDate > QDate_exposer_t;
QDate_exposer_t QDate_exposer = QDate_exposer_t( "QDate", bp::init< >() );
bp::scope QDate_scope( QDate_exposer );
QDate_exposer.def( bp::init< int, int, int >(( bp::arg("y"), bp::arg("m"), bp::arg("d") )) );
{ //::QDate::addDays
typedef ::QDate ( ::QDate::*addDays_function_type )( qint64 ) const;
addDays_function_type addDays_function_value( &::QDate::addDays );
QDate_exposer.def(
"addDays"
, addDays_function_value
, ( bp::arg("days") ) );
}
{ //::QDate::addMonths
typedef ::QDate ( ::QDate::*addMonths_function_type )( int ) const;
addMonths_function_type addMonths_function_value( &::QDate::addMonths );
QDate_exposer.def(
"addMonths"
, addMonths_function_value
, ( bp::arg("months") ) );
}
{ //::QDate::addYears
typedef ::QDate ( ::QDate::*addYears_function_type )( int ) const;
addYears_function_type addYears_function_value( &::QDate::addYears );
QDate_exposer.def(
"addYears"
, addYears_function_value
, ( bp::arg("years") ) );
}
{ //::QDate::currentDate
typedef ::QDate ( *currentDate_function_type )( );
currentDate_function_type currentDate_function_value( &::QDate::currentDate );
QDate_exposer.def(
"currentDate"
, currentDate_function_value );
}
{ //::QDate::day
typedef int ( ::QDate::*day_function_type )( ) const;
day_function_type day_function_value( &::QDate::day );
QDate_exposer.def(
"day"
, day_function_value );
}
{ //::QDate::dayOfWeek
typedef int ( ::QDate::*dayOfWeek_function_type )( ) const;
dayOfWeek_function_type dayOfWeek_function_value( &::QDate::dayOfWeek );
QDate_exposer.def(
"dayOfWeek"
, dayOfWeek_function_value );
}
{ //::QDate::dayOfYear
typedef int ( ::QDate::*dayOfYear_function_type )( ) const;
dayOfYear_function_type dayOfYear_function_value( &::QDate::dayOfYear );
QDate_exposer.def(
"dayOfYear"
, dayOfYear_function_value );
}
{ //::QDate::daysInMonth
typedef int ( ::QDate::*daysInMonth_function_type )( ) const;
daysInMonth_function_type daysInMonth_function_value( &::QDate::daysInMonth );
QDate_exposer.def(
"daysInMonth"
, daysInMonth_function_value );
}
{ //::QDate::daysInYear
typedef int ( ::QDate::*daysInYear_function_type )( ) const;
daysInYear_function_type daysInYear_function_value( &::QDate::daysInYear );
QDate_exposer.def(
"daysInYear"
, daysInYear_function_value );
}
{ //::QDate::daysTo
typedef qint64 ( ::QDate::*daysTo_function_type )( ::QDate const & ) const;
daysTo_function_type daysTo_function_value( &::QDate::daysTo );
QDate_exposer.def(
"daysTo"
, daysTo_function_value
, ( bp::arg("arg0") ) );
}
{ //::QDate::fromJulianDay
typedef ::QDate ( *fromJulianDay_function_type )( qint64 );
fromJulianDay_function_type fromJulianDay_function_value( &::QDate::fromJulianDay );
QDate_exposer.def(
"fromJulianDay"
, fromJulianDay_function_value
, ( bp::arg("jd") ) );
}
{ //::QDate::fromString
typedef ::QDate ( *fromString_function_type )( ::QString const &,::QString const & );
fromString_function_type fromString_function_value( &::QDate::fromString );
QDate_exposer.def(
"fromString"
, fromString_function_value
, ( bp::arg("s"), bp::arg("format") ) );
}
{ //::QDate::isLeapYear
typedef bool ( *isLeapYear_function_type )( int );
isLeapYear_function_type isLeapYear_function_value( &::QDate::isLeapYear );
QDate_exposer.def(
"isLeapYear"
, isLeapYear_function_value
, ( bp::arg("year") ) );
}
{ //::QDate::isNull
typedef bool ( ::QDate::*isNull_function_type )( ) const;
isNull_function_type isNull_function_value( &::QDate::isNull );
QDate_exposer.def(
"isNull"
, isNull_function_value );
}
{ //::QDate::isValid
typedef bool ( ::QDate::*isValid_function_type )( ) const;
isValid_function_type isValid_function_value( &::QDate::isValid );
QDate_exposer.def(
"isValid"
, isValid_function_value );
}
{ //::QDate::isValid
typedef bool ( *isValid_function_type )( int,int,int );
isValid_function_type isValid_function_value( &::QDate::isValid );
QDate_exposer.def(
"isValid"
, isValid_function_value
, ( bp::arg("y"), bp::arg("m"), bp::arg("d") ) );
}
{ //::QDate::longDayName
typedef ::QString ( *longDayName_function_type )( int, QDate::MonthNameType );
longDayName_function_type longDayName_function_value( &::QDate::longDayName );
QDate_exposer.def(
"longDayName"
, longDayName_function_value
, ( bp::arg("weekday") ) );
}
{ //::QDate::longMonthName
typedef ::QString ( *longMonthName_function_type )( int, QDate::MonthNameType );
longMonthName_function_type longMonthName_function_value( &::QDate::longMonthName );
QDate_exposer.def(
"longMonthName"
, longMonthName_function_value
, ( bp::arg("month") ) );
}
{ //::QDate::month
typedef int ( ::QDate::*month_function_type )( ) const;
month_function_type month_function_value( &::QDate::month );
QDate_exposer.def(
"month"
, month_function_value );
}
QDate_exposer.def( bp::self != bp::self );
QDate_exposer.def( bp::self < bp::self );
QDate_exposer.def( bp::self <= bp::self );
QDate_exposer.def( bp::self == bp::self );
QDate_exposer.def( bp::self > bp::self );
QDate_exposer.def( bp::self >= bp::self );
{ //::QDate::setDate
typedef bool ( ::QDate::*setDate_function_type )( int,int,int ) ;
setDate_function_type setDate_function_value( &::QDate::setDate );
QDate_exposer.def(
"setDate"
, setDate_function_value
, ( bp::arg("year"), bp::arg("month"), bp::arg("date") ) );
}
{ //::QDate::shortDayName
typedef ::QString ( *shortDayName_function_type )( int, QDate::MonthNameType );
shortDayName_function_type shortDayName_function_value( &::QDate::shortDayName );
QDate_exposer.def(
"shortDayName"
, shortDayName_function_value
, ( bp::arg("weekday") ) );
}
{ //::QDate::shortMonthName
typedef ::QString ( *shortMonthName_function_type )( int, QDate::MonthNameType );
shortMonthName_function_type shortMonthName_function_value( &::QDate::shortMonthName );
QDate_exposer.def(
"shortMonthName"
, shortMonthName_function_value
, ( bp::arg("month") ) );
}
{ //::QDate::toJulianDay
typedef qint64 ( ::QDate::*toJulianDay_function_type )( ) const;
toJulianDay_function_type toJulianDay_function_value( &::QDate::toJulianDay );
QDate_exposer.def(
"toJulianDay"
, toJulianDay_function_value );
}
{ //::QDate::toString
typedef ::QString ( ::QDate::*toString_function_type )( ::QString const & ) const;
toString_function_type toString_function_value( &::QDate::toString );
QDate_exposer.def(
"toString"
, toString_function_value
, ( bp::arg("format") ) );
}
{ //::QDate::weekNumber
typedef int ( ::QDate::*weekNumber_function_type )( int * ) const;
weekNumber_function_type weekNumber_function_value( &::QDate::weekNumber );
QDate_exposer.def(
"weekNumber"
, weekNumber_function_value
, ( bp::arg("yearNum")=bp::object() ) );
}
{ //::QDate::year
typedef int ( ::QDate::*year_function_type )( ) const;
year_function_type year_function_value( &::QDate::year );
QDate_exposer.def(
"year"
, year_function_value );
}
QDate_exposer.staticmethod( "currentDate" );
QDate_exposer.staticmethod( "fromJulianDay" );
QDate_exposer.staticmethod( "fromString" );
QDate_exposer.staticmethod( "isLeapYear" );
QDate_exposer.staticmethod( "isValid" );
QDate_exposer.staticmethod( "longDayName" );
QDate_exposer.staticmethod( "longMonthName" );
QDate_exposer.staticmethod( "shortDayName" );
QDate_exposer.staticmethod( "shortMonthName" );
QDate_exposer.def( "__copy__", &__copy__);
QDate_exposer.def( "__deepcopy__", &__copy__);
QDate_exposer.def( "clone", &__copy__);
QDate_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::QDate >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
QDate_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::QDate >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
}
}
void register_Velocity3D_class(){
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >
typedef bp::class_< SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > > Velocity3D_exposer_t;
Velocity3D_exposer_t Velocity3D_exposer = Velocity3D_exposer_t( "Velocity3D", bp::init< >() );
bp::scope Velocity3D_scope( Velocity3D_exposer );
Velocity3D_exposer.def( bp::init< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & >(( bp::arg("val") )) );
Velocity3D_exposer.def( bp::init< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const &, SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const &, SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & >(( bp::arg("x"), bp::arg("y"), bp::arg("z") )) );
Velocity3D_exposer.def( bp::init< SireMaths::Vector const & >(( bp::arg("v") )) );
Velocity3D_exposer.def( bp::init< SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > const & >(( bp::arg("other") )) );
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::at
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef ::SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*at_function_type )( int ) const;
at_function_type at_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::at );
Velocity3D_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::count
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef int ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*count_function_type )( ) const;
count_function_type count_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::count );
Velocity3D_exposer.def(
"count"
, count_function_value );
}
Velocity3D_exposer.def( bp::self != bp::self );
Velocity3D_exposer.def( bp::self * bp::other< double >() );
Velocity3D_exposer.def( bp::self + bp::self );
Velocity3D_exposer.def( -bp::self );
Velocity3D_exposer.def( bp::self - bp::self );
Velocity3D_exposer.def( bp::self / bp::other< double >() );
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::operator=
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > & ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*assign_function_type )( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > const & ) ;
assign_function_type assign_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::operator= );
Velocity3D_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
Velocity3D_exposer.def( bp::self == bp::self );
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::operator[]
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef ::SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*__getitem___function_type )( int ) const;
__getitem___function_type __getitem___function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::operator[] );
Velocity3D_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::set
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef void ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*set_function_type )( int,::SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & ) ;
set_function_type set_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::set );
Velocity3D_exposer.def(
"set"
, set_function_value
, ( bp::arg("i"), bp::arg("value") ) );
}
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::toString
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef ::QString ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::toString );
Velocity3D_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::typeName
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::typeName );
Velocity3D_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::value
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef ::SireMaths::Vector ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*value_function_type )( ) const;
value_function_type value_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::value );
Velocity3D_exposer.def(
"value"
, value_function_value );
}
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::x
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef ::SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*x_function_type )( ) const;
x_function_type x_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::x );
Velocity3D_exposer.def(
"x"
, x_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::y
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef ::SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*y_function_type )( ) const;
y_function_type y_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::y );
Velocity3D_exposer.def(
"y"
, y_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::z
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef ::SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*z_function_type )( ) const;
z_function_type z_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::z );
Velocity3D_exposer.def(
"z"
, z_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
Velocity3D_exposer.staticmethod( "typeName" );
Velocity3D_exposer.def( "__copy__", &__copy__);
Velocity3D_exposer.def( "__deepcopy__", &__copy__);
Velocity3D_exposer.def( "clone", &__copy__);
Velocity3D_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMaths::Vector3D<SireUnits::Dimension::PhysUnit<0, 1, -1, 0, 0, 0, 0> > >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Velocity3D_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMaths::Vector3D<SireUnits::Dimension::PhysUnit<0, 1, -1, 0, 0, 0, 0> > >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Velocity3D_exposer.def( "__str__", &__str__< ::SireMaths::Vector3D<SireUnits::Dimension::PhysUnit<0, 1, -1, 0, 0, 0, 0> > > );
Velocity3D_exposer.def( "__repr__", &__str__< ::SireMaths::Vector3D<SireUnits::Dimension::PhysUnit<0, 1, -1, 0, 0, 0, 0> > > );
Velocity3D_exposer.def( "__len__", &__len_count< ::SireMaths::Vector3D<SireUnits::Dimension::PhysUnit<0, 1, -1, 0, 0, 0, 0> > > );
}
}
void register_TripleDistanceComponent_class() {
{ //::SireSystem::TripleDistanceComponent
typedef bp::class_< SireSystem::TripleDistanceComponent, bp::bases< SireSystem::GeometryComponent, SireSystem::Constraint, SireBase::Property > > TripleDistanceComponent_exposer_t;
TripleDistanceComponent_exposer_t TripleDistanceComponent_exposer = TripleDistanceComponent_exposer_t( "TripleDistanceComponent", bp::init< >() );
bp::scope TripleDistanceComponent_scope( TripleDistanceComponent_exposer );
TripleDistanceComponent_exposer.def( bp::init< SireCAS::Symbol const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("constrained_symbol"), bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("point3"), bp::arg("point4"), bp::arg("point5"), bp::arg("map")=SireBase::PropertyMap() )) );
TripleDistanceComponent_exposer.def( bp::init< SireCAS::Symbol const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireCAS::Expression const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("constrained_symbol"), bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("point3"), bp::arg("point4"), bp::arg("point5"), bp::arg("geometry_expression"), bp::arg("map")=SireBase::PropertyMap() )) );
TripleDistanceComponent_exposer.def( bp::init< SireSystem::TripleDistanceComponent const & >(( bp::arg("other") )) );
{ //::SireSystem::TripleDistanceComponent::nPoints
typedef int ( ::SireSystem::TripleDistanceComponent::*nPoints_function_type )( ) const;
nPoints_function_type nPoints_function_value( &::SireSystem::TripleDistanceComponent::nPoints );
TripleDistanceComponent_exposer.def(
"nPoints"
, nPoints_function_value );
}
TripleDistanceComponent_exposer.def( bp::self != bp::self );
{ //::SireSystem::TripleDistanceComponent::operator=
typedef ::SireSystem::TripleDistanceComponent & ( ::SireSystem::TripleDistanceComponent::*assign_function_type )( ::SireSystem::TripleDistanceComponent const & ) ;
assign_function_type assign_function_value( &::SireSystem::TripleDistanceComponent::operator= );
TripleDistanceComponent_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
TripleDistanceComponent_exposer.def( bp::self == bp::self );
{ //::SireSystem::TripleDistanceComponent::point
typedef ::SireFF::Point const & ( ::SireSystem::TripleDistanceComponent::*point_function_type )( int ) const;
point_function_type point_function_value( &::SireSystem::TripleDistanceComponent::point );
TripleDistanceComponent_exposer.def(
"point"
, point_function_value
, ( bp::arg("i") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireSystem::TripleDistanceComponent::point0
typedef ::SireFF::Point const & ( ::SireSystem::TripleDistanceComponent::*point0_function_type )( ) const;
point0_function_type point0_function_value( &::SireSystem::TripleDistanceComponent::point0 );
TripleDistanceComponent_exposer.def(
"point0"
, point0_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireSystem::TripleDistanceComponent::point1
typedef ::SireFF::Point const & ( ::SireSystem::TripleDistanceComponent::*point1_function_type )( ) const;
point1_function_type point1_function_value( &::SireSystem::TripleDistanceComponent::point1 );
TripleDistanceComponent_exposer.def(
"point1"
, point1_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireSystem::TripleDistanceComponent::point2
typedef ::SireFF::Point const & ( ::SireSystem::TripleDistanceComponent::*point2_function_type )( ) const;
point2_function_type point2_function_value( &::SireSystem::TripleDistanceComponent::point2 );
TripleDistanceComponent_exposer.def(
"point2"
, point2_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireSystem::TripleDistanceComponent::point3
typedef ::SireFF::Point const & ( ::SireSystem::TripleDistanceComponent::*point3_function_type )( ) const;
point3_function_type point3_function_value( &::SireSystem::TripleDistanceComponent::point3 );
TripleDistanceComponent_exposer.def(
"point3"
, point3_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireSystem::TripleDistanceComponent::point4
typedef ::SireFF::Point const & ( ::SireSystem::TripleDistanceComponent::*point4_function_type )( ) const;
point4_function_type point4_function_value( &::SireSystem::TripleDistanceComponent::point4 );
TripleDistanceComponent_exposer.def(
"point4"
, point4_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireSystem::TripleDistanceComponent::point5
typedef ::SireFF::Point const & ( ::SireSystem::TripleDistanceComponent::*point5_function_type )( ) const;
point5_function_type point5_function_value( &::SireSystem::TripleDistanceComponent::point5 );
TripleDistanceComponent_exposer.def(
"point5"
, point5_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireSystem::TripleDistanceComponent::r01
typedef ::SireCAS::Symbol const & ( *r01_function_type )( );
r01_function_type r01_function_value( &::SireSystem::TripleDistanceComponent::r01 );
TripleDistanceComponent_exposer.def(
"r01"
, r01_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireSystem::TripleDistanceComponent::r23
typedef ::SireCAS::Symbol const & ( *r23_function_type )( );
r23_function_type r23_function_value( &::SireSystem::TripleDistanceComponent::r23 );
TripleDistanceComponent_exposer.def(
"r23"
, r23_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireSystem::TripleDistanceComponent::r45
typedef ::SireCAS::Symbol const & ( *r45_function_type )( );
r45_function_type r45_function_value( &::SireSystem::TripleDistanceComponent::r45 );
TripleDistanceComponent_exposer.def(
"r45"
, r45_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireSystem::TripleDistanceComponent::toString
typedef ::QString ( ::SireSystem::TripleDistanceComponent::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireSystem::TripleDistanceComponent::toString );
TripleDistanceComponent_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireSystem::TripleDistanceComponent::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireSystem::TripleDistanceComponent::typeName );
TripleDistanceComponent_exposer.def(
"typeName"
, typeName_function_value );
}
TripleDistanceComponent_exposer.staticmethod( "r01" );
TripleDistanceComponent_exposer.staticmethod( "r23" );
TripleDistanceComponent_exposer.staticmethod( "r45" );
TripleDistanceComponent_exposer.staticmethod( "typeName" );
TripleDistanceComponent_exposer.def( "__copy__", &__copy__);
TripleDistanceComponent_exposer.def( "__deepcopy__", &__copy__);
TripleDistanceComponent_exposer.def( "clone", &__copy__);
TripleDistanceComponent_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireSystem::TripleDistanceComponent >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
TripleDistanceComponent_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireSystem::TripleDistanceComponent >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
TripleDistanceComponent_exposer.def( "__str__", &__str__< ::SireSystem::TripleDistanceComponent > );
TripleDistanceComponent_exposer.def( "__repr__", &__str__< ::SireSystem::TripleDistanceComponent > );
}
}
void register_IDOrSet_SegID__class(){
{ //::SireID::IDOrSet< SireMol::SegID >
typedef bp::class_< SireID::IDOrSet< SireMol::SegID >, bp::bases< SireMol::SegID, SireID::ID > > IDOrSet_SegID__exposer_t;
IDOrSet_SegID__exposer_t IDOrSet_SegID__exposer = IDOrSet_SegID__exposer_t( "IDOrSet_SegID_", bp::init< >() );
bp::scope IDOrSet_SegID__scope( IDOrSet_SegID__exposer );
IDOrSet_SegID__exposer.def( bp::init< SireMol::SegID const & >(( bp::arg("id") )) );
IDOrSet_SegID__exposer.def( bp::init< SireMol::SegID const &, SireMol::SegID const & >(( bp::arg("id0"), bp::arg("id1") )) );
IDOrSet_SegID__exposer.def( bp::init< QList< SireMol::SegIdentifier > const & >(( bp::arg("ids") )) );
IDOrSet_SegID__exposer.def( bp::init< SireID::IDOrSet< SireMol::SegID > const & >(( bp::arg("other") )) );
{ //::SireID::IDOrSet< SireMol::SegID >::IDs
typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
typedef ::QSet< SireMol::SegIdentifier > const & ( ::SireID::IDOrSet< SireMol::SegID >::*IDs_function_type )( ) const;
IDs_function_type IDs_function_value( &::SireID::IDOrSet< SireMol::SegID >::IDs );
IDOrSet_SegID__exposer.def(
"IDs"
, IDs_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireID::IDOrSet< SireMol::SegID >::hash
typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
typedef ::uint ( ::SireID::IDOrSet< SireMol::SegID >::*hash_function_type )( ) const;
hash_function_type hash_function_value( &::SireID::IDOrSet< SireMol::SegID >::hash );
IDOrSet_SegID__exposer.def(
"hash"
, hash_function_value );
}
{ //::SireID::IDOrSet< SireMol::SegID >::isNull
typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
typedef bool ( ::SireID::IDOrSet< SireMol::SegID >::*isNull_function_type )( ) const;
isNull_function_type isNull_function_value( &::SireID::IDOrSet< SireMol::SegID >::isNull );
IDOrSet_SegID__exposer.def(
"isNull"
, isNull_function_value );
}
{ //::SireID::IDOrSet< SireMol::SegID >::map
typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
typedef ::QList< SireMol::SegIdx > ( ::SireID::IDOrSet< SireMol::SegID >::*map_function_type )( ::SireMol::MolInfo const & ) const;
map_function_type map_function_value( &::SireID::IDOrSet< SireMol::SegID >::map );
IDOrSet_SegID__exposer.def(
"map"
, map_function_value
, ( bp::arg("obj") ) );
}
IDOrSet_SegID__exposer.def( bp::self != bp::other< SireID::ID >() );
IDOrSet_SegID__exposer.def( bp::self != bp::self );
IDOrSet_SegID__exposer.def( bp::self != bp::other< SireMol::SegID >() );
{ //::SireID::IDOrSet< SireMol::SegID >::operator=
typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
typedef ::SireID::IDOrSet< SireMol::SegID > & ( ::SireID::IDOrSet< SireMol::SegID >::*assign_function_type )( ::SireID::IDOrSet< SireMol::SegID > const & ) ;
assign_function_type assign_function_value( &::SireID::IDOrSet< SireMol::SegID >::operator= );
IDOrSet_SegID__exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
{ //::SireID::IDOrSet< SireMol::SegID >::operator=
typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
typedef ::SireID::IDOrSet< SireMol::SegID > & ( ::SireID::IDOrSet< SireMol::SegID >::*assign_function_type )( ::SireMol::SegID const & ) ;
assign_function_type assign_function_value( &::SireID::IDOrSet< SireMol::SegID >::operator= );
IDOrSet_SegID__exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
IDOrSet_SegID__exposer.def( bp::self == bp::other< SireID::ID >() );
IDOrSet_SegID__exposer.def( bp::self == bp::self );
IDOrSet_SegID__exposer.def( bp::self == bp::other< SireMol::SegID >() );
{ //::SireID::IDOrSet< SireMol::SegID >::toString
typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
typedef ::QString ( ::SireID::IDOrSet< SireMol::SegID >::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireID::IDOrSet< SireMol::SegID >::toString );
IDOrSet_SegID__exposer.def(
"toString"
, toString_function_value );
}
{ //::SireID::IDOrSet< SireMol::SegID >::typeName
typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireID::IDOrSet< SireMol::SegID >::typeName );
IDOrSet_SegID__exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireID::IDOrSet< SireMol::SegID >::what
typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
typedef char const * ( ::SireID::IDOrSet< SireMol::SegID >::*what_function_type )( ) const;
what_function_type what_function_value( &::SireID::IDOrSet< SireMol::SegID >::what );
IDOrSet_SegID__exposer.def(
"what"
, what_function_value );
}
IDOrSet_SegID__exposer.staticmethod( "typeName" );
IDOrSet_SegID__exposer.def( "__copy__", &__copy__);
IDOrSet_SegID__exposer.def( "__deepcopy__", &__copy__);
IDOrSet_SegID__exposer.def( "clone", &__copy__);
IDOrSet_SegID__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireID::IDOrSet<SireMol::SegID> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
IDOrSet_SegID__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireID::IDOrSet<SireMol::SegID> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
IDOrSet_SegID__exposer.def( "__str__", &__str__< ::SireID::IDOrSet<SireMol::SegID> > );
IDOrSet_SegID__exposer.def( "__repr__", &__str__< ::SireID::IDOrSet<SireMol::SegID> > );
}
}
void register_Segment_class(){
{ //::SireMol::Segment
typedef bp::class_< SireMol::Segment, bp::bases< SireMol::MoleculeView, SireBase::Property > > Segment_exposer_t;
Segment_exposer_t Segment_exposer = Segment_exposer_t( "Segment", bp::init< >() );
bp::scope Segment_scope( Segment_exposer );
Segment_exposer.def( bp::init< SireMol::MoleculeData const &, SireMol::SegID const & >(( bp::arg("data"), bp::arg("segid") )) );
Segment_exposer.def( bp::init< SireMol::Segment const & >(( bp::arg("other") )) );
{ //::SireMol::Segment::assertContainsMetadata
typedef void ( ::SireMol::Segment::*assertContainsMetadata_function_type )( ::SireBase::PropertyName const & ) const;
assertContainsMetadata_function_type assertContainsMetadata_function_value( &::SireMol::Segment::assertContainsMetadata );
Segment_exposer.def(
"assertContainsMetadata"
, assertContainsMetadata_function_value
, ( bp::arg("metakey") ) );
}
{ //::SireMol::Segment::assertContainsMetadata
typedef void ( ::SireMol::Segment::*assertContainsMetadata_function_type )( ::SireBase::PropertyName const &,::SireBase::PropertyName const & ) const;
assertContainsMetadata_function_type assertContainsMetadata_function_value( &::SireMol::Segment::assertContainsMetadata );
Segment_exposer.def(
"assertContainsMetadata"
, assertContainsMetadata_function_value
, ( bp::arg("key"), bp::arg("metakey") ) );
}
{ //::SireMol::Segment::assertContainsProperty
typedef void ( ::SireMol::Segment::*assertContainsProperty_function_type )( ::SireBase::PropertyName const & ) const;
assertContainsProperty_function_type assertContainsProperty_function_value( &::SireMol::Segment::assertContainsProperty );
Segment_exposer.def(
"assertContainsProperty"
, assertContainsProperty_function_value
, ( bp::arg("key") ) );
}
{ //::SireMol::Segment::atomIdxs
typedef ::QList< SireMol::AtomIdx > const & ( ::SireMol::Segment::*atomIdxs_function_type )( ) const;
atomIdxs_function_type atomIdxs_function_value( &::SireMol::Segment::atomIdxs );
Segment_exposer.def(
"atomIdxs"
, atomIdxs_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMol::Segment::contains
typedef bool ( ::SireMol::Segment::*contains_function_type )( ::SireMol::AtomIdx ) const;
contains_function_type contains_function_value( &::SireMol::Segment::contains );
Segment_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("atomidx") ) );
}
{ //::SireMol::Segment::contains
typedef bool ( ::SireMol::Segment::*contains_function_type )( ::SireMol::AtomID const & ) const;
contains_function_type contains_function_value( &::SireMol::Segment::contains );
Segment_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("atomid") ) );
}
{ //::SireMol::Segment::edit
typedef ::SireMol::SegEditor ( ::SireMol::Segment::*edit_function_type )( ) const;
edit_function_type edit_function_value( &::SireMol::Segment::edit );
Segment_exposer.def(
"edit"
, edit_function_value );
}
{ //::SireMol::Segment::evaluate
typedef ::SireMol::Evaluator ( ::SireMol::Segment::*evaluate_function_type )( ) const;
evaluate_function_type evaluate_function_value( &::SireMol::Segment::evaluate );
Segment_exposer.def(
"evaluate"
, evaluate_function_value );
}
{ //::SireMol::Segment::hasMetadata
typedef bool ( ::SireMol::Segment::*hasMetadata_function_type )( ::SireBase::PropertyName const & ) const;
hasMetadata_function_type hasMetadata_function_value( &::SireMol::Segment::hasMetadata );
Segment_exposer.def(
"hasMetadata"
, hasMetadata_function_value
, ( bp::arg("metakey") ) );
}
{ //::SireMol::Segment::hasMetadata
typedef bool ( ::SireMol::Segment::*hasMetadata_function_type )( ::SireBase::PropertyName const &,::SireBase::PropertyName const & ) const;
hasMetadata_function_type hasMetadata_function_value( &::SireMol::Segment::hasMetadata );
Segment_exposer.def(
"hasMetadata"
, hasMetadata_function_value
, ( bp::arg("key"), bp::arg("metakey") ) );
}
{ //::SireMol::Segment::hasProperty
typedef bool ( ::SireMol::Segment::*hasProperty_function_type )( ::SireBase::PropertyName const & ) const;
hasProperty_function_type hasProperty_function_value( &::SireMol::Segment::hasProperty );
Segment_exposer.def(
"hasProperty"
, hasProperty_function_value
, ( bp::arg("key") ) );
}
{ //::SireMol::Segment::index
typedef ::SireMol::SegIdx ( ::SireMol::Segment::*index_function_type )( ) const;
index_function_type index_function_value( &::SireMol::Segment::index );
Segment_exposer.def(
"index"
, index_function_value );
}
{ //::SireMol::Segment::intersects
typedef bool ( ::SireMol::Segment::*intersects_function_type )( ::SireMol::AtomID const & ) const;
intersects_function_type intersects_function_value( &::SireMol::Segment::intersects );
Segment_exposer.def(
"intersects"
, intersects_function_value
, ( bp::arg("atomid") ) );
}
{ //::SireMol::Segment::isEmpty
typedef bool ( ::SireMol::Segment::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireMol::Segment::isEmpty );
Segment_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireMol::Segment::metadataKeys
typedef ::QStringList ( ::SireMol::Segment::*metadataKeys_function_type )( ) const;
metadataKeys_function_type metadataKeys_function_value( &::SireMol::Segment::metadataKeys );
Segment_exposer.def(
"metadataKeys"
, metadataKeys_function_value );
}
{ //::SireMol::Segment::metadataKeys
typedef ::QStringList ( ::SireMol::Segment::*metadataKeys_function_type )( ::SireBase::PropertyName const & ) const;
metadataKeys_function_type metadataKeys_function_value( &::SireMol::Segment::metadataKeys );
Segment_exposer.def(
"metadataKeys"
, metadataKeys_function_value
, ( bp::arg("key") ) );
}
{ //::SireMol::Segment::move
typedef ::SireMol::Mover< SireMol::Segment > ( ::SireMol::Segment::*move_function_type )( ) const;
move_function_type move_function_value( &::SireMol::Segment::move );
Segment_exposer.def(
"move"
, move_function_value );
}
{ //::SireMol::Segment::nAtoms
typedef int ( ::SireMol::Segment::*nAtoms_function_type )( ) const;
nAtoms_function_type nAtoms_function_value( &::SireMol::Segment::nAtoms );
Segment_exposer.def(
"nAtoms"
, nAtoms_function_value );
}
{ //::SireMol::Segment::name
typedef ::SireMol::SegName const & ( ::SireMol::Segment::*name_function_type )( ) const;
name_function_type name_function_value( &::SireMol::Segment::name );
Segment_exposer.def(
"name"
, name_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
Segment_exposer.def( bp::self != bp::self );
{ //::SireMol::Segment::operator=
typedef ::SireMol::Segment & ( ::SireMol::Segment::*assign_function_type )( ::SireMol::Segment const & ) ;
assign_function_type assign_function_value( &::SireMol::Segment::operator= );
Segment_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
Segment_exposer.def( bp::self == bp::self );
{ //::SireMol::Segment::propertyKeys
typedef ::QStringList ( ::SireMol::Segment::*propertyKeys_function_type )( ) const;
propertyKeys_function_type propertyKeys_function_value( &::SireMol::Segment::propertyKeys );
Segment_exposer.def(
"propertyKeys"
, propertyKeys_function_value );
}
{ //::SireMol::Segment::selectedAll
typedef bool ( ::SireMol::Segment::*selectedAll_function_type )( ) const;
selectedAll_function_type selectedAll_function_value( &::SireMol::Segment::selectedAll );
Segment_exposer.def(
"selectedAll"
, selectedAll_function_value );
}
{ //::SireMol::Segment::selection
typedef ::SireMol::AtomSelection ( ::SireMol::Segment::*selection_function_type )( ) const;
selection_function_type selection_function_value( &::SireMol::Segment::selection );
Segment_exposer.def(
"selection"
, selection_function_value );
}
{ //::SireMol::Segment::selector
typedef ::SireMol::Selector< SireMol::Segment > ( ::SireMol::Segment::*selector_function_type )( ) const;
selector_function_type selector_function_value( &::SireMol::Segment::selector );
Segment_exposer.def(
"selector"
, selector_function_value );
}
{ //::SireMol::Segment::toString
typedef ::QString ( ::SireMol::Segment::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMol::Segment::toString );
Segment_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMol::Segment::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::Segment::typeName );
Segment_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMol::Segment::update
typedef void ( ::SireMol::Segment::*update_function_type )( ::SireMol::MoleculeData const & ) ;
update_function_type update_function_value( &::SireMol::Segment::update );
Segment_exposer.def(
"update"
, update_function_value
, ( bp::arg("moldata") ) );
}
Segment_exposer.staticmethod( "typeName" );
Segment_exposer.def( "_get_property_SireMol_SegStringProperty", &SireMol::Segment::property< QString >, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_metadata_SireMol_SegStringProperty", get_Metadata_SireMol_SegStringProperty_function1, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_metadata_SireMol_SegStringProperty", &get_Metadata_SireMol_SegStringProperty_function2, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_property_SireMol_SegIntProperty", &SireMol::Segment::property< qint64 >, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_metadata_SireMol_SegIntProperty", get_Metadata_SireMol_SegIntProperty_function1, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_metadata_SireMol_SegIntProperty", &get_Metadata_SireMol_SegIntProperty_function2, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_property_SireMol_SegFloatProperty", &SireMol::Segment::property< double >, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_metadata_SireMol_SegFloatProperty", get_Metadata_SireMol_SegFloatProperty_function1, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_metadata_SireMol_SegFloatProperty", &get_Metadata_SireMol_SegFloatProperty_function2, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_property_SireMol_SegVariantProperty", &SireMol::Segment::property< QVariant >, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_metadata_SireMol_SegVariantProperty", get_Metadata_SireMol_SegVariantProperty_function1, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_metadata_SireMol_SegVariantProperty", &get_Metadata_SireMol_SegVariantProperty_function2, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "__copy__", &__copy__);
Segment_exposer.def( "__deepcopy__", &__copy__);
Segment_exposer.def( "clone", &__copy__);
Segment_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::Segment >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Segment_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::Segment >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Segment_exposer.def( "__str__", &__str__< ::SireMol::Segment > );
Segment_exposer.def( "__repr__", &__str__< ::SireMol::Segment > );
}
}
void register_MolWithResID_class(){
{ //::SireMol::MolWithResID
typedef bp::class_< SireMol::MolWithResID, bp::bases< SireMol::MolID, SireID::ID > > MolWithResID_exposer_t;
MolWithResID_exposer_t MolWithResID_exposer = MolWithResID_exposer_t( "MolWithResID", bp::init< >() );
bp::scope MolWithResID_scope( MolWithResID_exposer );
MolWithResID_exposer.def( bp::init< QString const & >(( bp::arg("resname") )) );
MolWithResID_exposer.def( bp::init< int >(( bp::arg("resnum") )) );
MolWithResID_exposer.def( bp::init< SireMol::ResID const & >(( bp::arg("resid") )) );
MolWithResID_exposer.def( bp::init< QString const &, SireID::CaseSensitivity >(( bp::arg("resname"), bp::arg("case_sensitivity") )) );
MolWithResID_exposer.def( bp::init< SireMol::MolWithResID const & >(( bp::arg("other") )) );
{ //::SireMol::MolWithResID::hash
typedef ::uint ( ::SireMol::MolWithResID::*hash_function_type )( ) const;
hash_function_type hash_function_value( &::SireMol::MolWithResID::hash );
MolWithResID_exposer.def(
"hash"
, hash_function_value );
}
{ //::SireMol::MolWithResID::isNull
typedef bool ( ::SireMol::MolWithResID::*isNull_function_type )( ) const;
isNull_function_type isNull_function_value( &::SireMol::MolWithResID::isNull );
MolWithResID_exposer.def(
"isNull"
, isNull_function_value );
}
{ //::SireMol::MolWithResID::map
typedef ::QList< SireMol::MolNum > ( ::SireMol::MolWithResID::*map_function_type )( ::SireMol::Molecules const & ) const;
map_function_type map_function_value( &::SireMol::MolWithResID::map );
MolWithResID_exposer.def(
"map"
, map_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireMol::MolWithResID::map
typedef ::QList< SireMol::MolNum > ( ::SireMol::MolWithResID::*map_function_type )( ::SireMol::MoleculeGroup const & ) const;
map_function_type map_function_value( &::SireMol::MolWithResID::map );
MolWithResID_exposer.def(
"map"
, map_function_value
, ( bp::arg("molgroup") ) );
}
{ //::SireMol::MolWithResID::map
typedef ::QList< SireMol::MolNum > ( ::SireMol::MolWithResID::*map_function_type )( ::SireMol::MolGroupsBase const & ) const;
map_function_type map_function_value( &::SireMol::MolWithResID::map );
MolWithResID_exposer.def(
"map"
, map_function_value
, ( bp::arg("molgroups") ) );
}
MolWithResID_exposer.def( bp::self != bp::self );
{ //::SireMol::MolWithResID::operator=
typedef ::SireMol::MolWithResID & ( ::SireMol::MolWithResID::*assign_function_type )( ::SireMol::MolWithResID const & ) ;
assign_function_type assign_function_value( &::SireMol::MolWithResID::operator= );
MolWithResID_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
MolWithResID_exposer.def( bp::self == bp::other< SireID::ID >() );
MolWithResID_exposer.def( bp::self == bp::self );
{ //::SireMol::MolWithResID::resID
typedef ::SireMol::ResID const & ( ::SireMol::MolWithResID::*resID_function_type )( ) const;
resID_function_type resID_function_value( &::SireMol::MolWithResID::resID );
MolWithResID_exposer.def(
"resID"
, resID_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::MolWithResID::toString
typedef ::QString ( ::SireMol::MolWithResID::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMol::MolWithResID::toString );
MolWithResID_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMol::MolWithResID::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::MolWithResID::typeName );
MolWithResID_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMol::MolWithResID::what
typedef char const * ( ::SireMol::MolWithResID::*what_function_type )( ) const;
what_function_type what_function_value( &::SireMol::MolWithResID::what );
MolWithResID_exposer.def(
"what"
, what_function_value );
}
MolWithResID_exposer.staticmethod( "typeName" );
MolWithResID_exposer.def( "__copy__", &__copy__);
MolWithResID_exposer.def( "__deepcopy__", &__copy__);
MolWithResID_exposer.def( "clone", &__copy__);
MolWithResID_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::MolWithResID >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
MolWithResID_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::MolWithResID >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
MolWithResID_exposer.def( "__str__", &__str__< ::SireMol::MolWithResID > );
MolWithResID_exposer.def( "__repr__", &__str__< ::SireMol::MolWithResID > );
}
}
void register_GeneralUnit_class(){
{ //::SireUnits::Dimension::GeneralUnit
typedef bp::class_< SireUnits::Dimension::GeneralUnit, bp::bases< SireUnits::Dimension::Unit > > GeneralUnit_exposer_t;
GeneralUnit_exposer_t GeneralUnit_exposer = GeneralUnit_exposer_t( "GeneralUnit", bp::init< >() );
bp::scope GeneralUnit_scope( GeneralUnit_exposer );
GeneralUnit_exposer.def( bp::init< SireUnits::Dimension::GeneralUnit const & >(( bp::arg("other") )) );
{ //::SireUnits::Dimension::GeneralUnit::ANGLE
typedef int ( ::SireUnits::Dimension::GeneralUnit::*ANGLE_function_type )( ) const;
ANGLE_function_type ANGLE_function_value( &::SireUnits::Dimension::GeneralUnit::ANGLE );
GeneralUnit_exposer.def(
"ANGLE"
, ANGLE_function_value );
}
{ //::SireUnits::Dimension::GeneralUnit::CHARGE
typedef int ( ::SireUnits::Dimension::GeneralUnit::*CHARGE_function_type )( ) const;
CHARGE_function_type CHARGE_function_value( &::SireUnits::Dimension::GeneralUnit::CHARGE );
GeneralUnit_exposer.def(
"CHARGE"
, CHARGE_function_value );
}
{ //::SireUnits::Dimension::GeneralUnit::LENGTH
typedef int ( ::SireUnits::Dimension::GeneralUnit::*LENGTH_function_type )( ) const;
LENGTH_function_type LENGTH_function_value( &::SireUnits::Dimension::GeneralUnit::LENGTH );
GeneralUnit_exposer.def(
"LENGTH"
, LENGTH_function_value );
}
{ //::SireUnits::Dimension::GeneralUnit::MASS
typedef int ( ::SireUnits::Dimension::GeneralUnit::*MASS_function_type )( ) const;
MASS_function_type MASS_function_value( &::SireUnits::Dimension::GeneralUnit::MASS );
GeneralUnit_exposer.def(
"MASS"
, MASS_function_value );
}
{ //::SireUnits::Dimension::GeneralUnit::QUANTITY
typedef int ( ::SireUnits::Dimension::GeneralUnit::*QUANTITY_function_type )( ) const;
QUANTITY_function_type QUANTITY_function_value( &::SireUnits::Dimension::GeneralUnit::QUANTITY );
GeneralUnit_exposer.def(
"QUANTITY"
, QUANTITY_function_value );
}
{ //::SireUnits::Dimension::GeneralUnit::TEMPERATURE
typedef int ( ::SireUnits::Dimension::GeneralUnit::*TEMPERATURE_function_type )( ) const;
TEMPERATURE_function_type TEMPERATURE_function_value( &::SireUnits::Dimension::GeneralUnit::TEMPERATURE );
GeneralUnit_exposer.def(
"TEMPERATURE"
, TEMPERATURE_function_value );
}
{ //::SireUnits::Dimension::GeneralUnit::TIME
typedef int ( ::SireUnits::Dimension::GeneralUnit::*TIME_function_type )( ) const;
TIME_function_type TIME_function_value( &::SireUnits::Dimension::GeneralUnit::TIME );
GeneralUnit_exposer.def(
"TIME"
, TIME_function_value );
}
{ //::SireUnits::Dimension::GeneralUnit::invert
typedef ::SireUnits::Dimension::GeneralUnit ( ::SireUnits::Dimension::GeneralUnit::*invert_function_type )( ) const;
invert_function_type invert_function_value( &::SireUnits::Dimension::GeneralUnit::invert );
GeneralUnit_exposer.def(
"invert"
, invert_function_value );
}
GeneralUnit_exposer.def( bp::self != bp::self );
GeneralUnit_exposer.def( bp::self * bp::self );
GeneralUnit_exposer.def( bp::self * bp::other< double >() );
GeneralUnit_exposer.def( bp::self * bp::other< int >() );
GeneralUnit_exposer.def( bp::self *= bp::self );
GeneralUnit_exposer.def( bp::self + bp::self );
GeneralUnit_exposer.def( -bp::self );
GeneralUnit_exposer.def( bp::self - bp::self );
GeneralUnit_exposer.def( bp::self / bp::self );
GeneralUnit_exposer.def( bp::self / bp::other< double >() );
GeneralUnit_exposer.def( bp::self / bp::other< int >() );
GeneralUnit_exposer.def( bp::self /= bp::self );
{ //::SireUnits::Dimension::GeneralUnit::operator=
typedef ::SireUnits::Dimension::GeneralUnit & ( ::SireUnits::Dimension::GeneralUnit::*assign_function_type )( ::SireUnits::Dimension::GeneralUnit const & ) ;
assign_function_type assign_function_value( &::SireUnits::Dimension::GeneralUnit::operator= );
GeneralUnit_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
GeneralUnit_exposer.def( bp::self == bp::self );
{ //::SireUnits::Dimension::GeneralUnit::to
typedef double ( ::SireUnits::Dimension::GeneralUnit::*to_function_type )( ::SireUnits::Dimension::TempBase const & ) const;
to_function_type to_function_value( &::SireUnits::Dimension::GeneralUnit::to );
GeneralUnit_exposer.def(
"to"
, to_function_value
, ( bp::arg("other") ) );
}
{ //::SireUnits::Dimension::GeneralUnit::to
typedef double ( ::SireUnits::Dimension::GeneralUnit::*to_function_type )( ::SireUnits::Dimension::GeneralUnit const & ) const;
to_function_type to_function_value( &::SireUnits::Dimension::GeneralUnit::to );
GeneralUnit_exposer.def(
"to"
, to_function_value
, ( bp::arg("other") ) );
}
{ //::SireUnits::Dimension::GeneralUnit::toString
typedef ::QString ( ::SireUnits::Dimension::GeneralUnit::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireUnits::Dimension::GeneralUnit::toString );
GeneralUnit_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireUnits::Dimension::GeneralUnit::typeName
typedef ::QString ( ::SireUnits::Dimension::GeneralUnit::*typeName_function_type )( ) const;
typeName_function_type typeName_function_value( &::SireUnits::Dimension::GeneralUnit::typeName );
GeneralUnit_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireUnits::Dimension::GeneralUnit::what
typedef ::QString ( ::SireUnits::Dimension::GeneralUnit::*what_function_type )( ) const;
what_function_type what_function_value( &::SireUnits::Dimension::GeneralUnit::what );
GeneralUnit_exposer.def(
"what"
, what_function_value );
}
GeneralUnit_exposer.def( bp::other<double>() * bp::self );
GeneralUnit_exposer.def( bp::other<double>() / bp::self );
GeneralUnit_exposer.def( "__copy__", &__copy__);
GeneralUnit_exposer.def( "__deepcopy__", &__copy__);
GeneralUnit_exposer.def( "clone", &__copy__);
GeneralUnit_exposer.def( "__str__", &__str__< ::SireUnits::Dimension::GeneralUnit > );
GeneralUnit_exposer.def( "__repr__", &__str__< ::SireUnits::Dimension::GeneralUnit > );
}
}
void register_CLJ14Group_class(){
{ //::SireMM::CLJ14Group
typedef bp::class_< SireMM::CLJ14Group > CLJ14Group_exposer_t;
CLJ14Group_exposer_t CLJ14Group_exposer = CLJ14Group_exposer_t( "CLJ14Group", bp::init< >() );
bp::scope CLJ14Group_scope( CLJ14Group_exposer );
CLJ14Group_exposer.def( bp::init< SireMol::MoleculeView const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("molecule"), bp::arg("map")=SireBase::PropertyMap() )) );
CLJ14Group_exposer.def( bp::init< SireMol::MoleculeView const &, SireMM::CLJFunction::COMBINING_RULES, bool, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("molecule"), bp::arg("combining_rules"), bp::arg("is_strict"), bp::arg("map")=SireBase::PropertyMap() )) );
CLJ14Group_exposer.def( bp::init< SireMM::CLJ14Group const & >(( bp::arg("other") )) );
{ //::SireMM::CLJ14Group::add
typedef void ( ::SireMM::CLJ14Group::*add_function_type )( ::SireMol::MoleculeView const & ) ;
add_function_type add_function_value( &::SireMM::CLJ14Group::add );
CLJ14Group_exposer.def(
"add"
, add_function_value
, ( bp::arg("new_molecule") ) );
}
{ //::SireMM::CLJ14Group::add
typedef void ( ::SireMM::CLJ14Group::*add_function_type )( ::SireMol::AtomSelection const & ) ;
add_function_type add_function_value( &::SireMM::CLJ14Group::add );
CLJ14Group_exposer.def(
"add"
, add_function_value
, ( bp::arg("new_selection") ) );
}
{ //::SireMM::CLJ14Group::combiningRules
typedef ::SireMM::CLJFunction::COMBINING_RULES ( ::SireMM::CLJ14Group::*combiningRules_function_type )( ) const;
combiningRules_function_type combiningRules_function_value( &::SireMM::CLJ14Group::combiningRules );
CLJ14Group_exposer.def(
"combiningRules"
, combiningRules_function_value );
}
{ //::SireMM::CLJ14Group::energy
typedef ::boost::tuples::tuple< double, double, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type > ( ::SireMM::CLJ14Group::*energy_function_type )( ) ;
energy_function_type energy_function_value( &::SireMM::CLJ14Group::energy );
CLJ14Group_exposer.def(
"energy"
, energy_function_value );
}
{ //::SireMM::CLJ14Group::isNull
typedef bool ( ::SireMM::CLJ14Group::*isNull_function_type )( ) const;
isNull_function_type isNull_function_value( &::SireMM::CLJ14Group::isNull );
CLJ14Group_exposer.def(
"isNull"
, isNull_function_value );
}
{ //::SireMM::CLJ14Group::isStrict
typedef bool ( ::SireMM::CLJ14Group::*isStrict_function_type )( ) const;
isStrict_function_type isStrict_function_value( &::SireMM::CLJ14Group::isStrict );
CLJ14Group_exposer.def(
"isStrict"
, isStrict_function_value );
}
{ //::SireMM::CLJ14Group::molecule
typedef ::SireMol::MoleculeView const & ( ::SireMM::CLJ14Group::*molecule_function_type )( ) const;
molecule_function_type molecule_function_value( &::SireMM::CLJ14Group::molecule );
CLJ14Group_exposer.def(
"molecule"
, molecule_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMM::CLJ14Group::mustNowRecalculateFromScratch
typedef void ( ::SireMM::CLJ14Group::*mustNowRecalculateFromScratch_function_type )( ) ;
mustNowRecalculateFromScratch_function_type mustNowRecalculateFromScratch_function_value( &::SireMM::CLJ14Group::mustNowRecalculateFromScratch );
CLJ14Group_exposer.def(
"mustNowRecalculateFromScratch"
, mustNowRecalculateFromScratch_function_value );
}
{ //::SireMM::CLJ14Group::mustReallyRecalculateFromScratch
typedef void ( ::SireMM::CLJ14Group::*mustReallyRecalculateFromScratch_function_type )( ) ;
mustReallyRecalculateFromScratch_function_type mustReallyRecalculateFromScratch_function_value( &::SireMM::CLJ14Group::mustReallyRecalculateFromScratch );
CLJ14Group_exposer.def(
"mustReallyRecalculateFromScratch"
, mustReallyRecalculateFromScratch_function_value );
}
CLJ14Group_exposer.def( bp::self != bp::self );
{ //::SireMM::CLJ14Group::operator=
typedef ::SireMM::CLJ14Group & ( ::SireMM::CLJ14Group::*assign_function_type )( ::SireMM::CLJ14Group const & ) ;
assign_function_type assign_function_value( &::SireMM::CLJ14Group::operator= );
CLJ14Group_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
CLJ14Group_exposer.def( bp::self == bp::self );
{ //::SireMM::CLJ14Group::propertyMap
typedef ::SireBase::PropertyMap ( ::SireMM::CLJ14Group::*propertyMap_function_type )( ) const;
propertyMap_function_type propertyMap_function_value( &::SireMM::CLJ14Group::propertyMap );
CLJ14Group_exposer.def(
"propertyMap"
, propertyMap_function_value );
}
{ //::SireMM::CLJ14Group::recalculatingFromScratch
typedef bool ( ::SireMM::CLJ14Group::*recalculatingFromScratch_function_type )( ) const;
recalculatingFromScratch_function_type recalculatingFromScratch_function_value( &::SireMM::CLJ14Group::recalculatingFromScratch );
CLJ14Group_exposer.def(
"recalculatingFromScratch"
, recalculatingFromScratch_function_value );
}
{ //::SireMM::CLJ14Group::remove
typedef void ( ::SireMM::CLJ14Group::*remove_function_type )( ::SireMol::AtomSelection const & ) ;
remove_function_type remove_function_value( &::SireMM::CLJ14Group::remove );
CLJ14Group_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("new_selection") ) );
}
{ //::SireMM::CLJ14Group::remove
typedef void ( ::SireMM::CLJ14Group::*remove_function_type )( ::SireMol::MoleculeView const & ) ;
remove_function_type remove_function_value( &::SireMM::CLJ14Group::remove );
CLJ14Group_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("new_molecule") ) );
}
{ //::SireMM::CLJ14Group::setArithmeticCombiningRules
typedef void ( ::SireMM::CLJ14Group::*setArithmeticCombiningRules_function_type )( bool ) ;
setArithmeticCombiningRules_function_type setArithmeticCombiningRules_function_value( &::SireMM::CLJ14Group::setArithmeticCombiningRules );
CLJ14Group_exposer.def(
"setArithmeticCombiningRules"
, setArithmeticCombiningRules_function_value
, ( bp::arg("on") ) );
}
{ //::SireMM::CLJ14Group::setCombiningRules
typedef void ( ::SireMM::CLJ14Group::*setCombiningRules_function_type )( ::SireMM::CLJFunction::COMBINING_RULES ) ;
setCombiningRules_function_type setCombiningRules_function_value( &::SireMM::CLJ14Group::setCombiningRules );
CLJ14Group_exposer.def(
"setCombiningRules"
, setCombiningRules_function_value
, ( bp::arg("rules") ) );
}
{ //::SireMM::CLJ14Group::setGeometricCombiningRules
typedef void ( ::SireMM::CLJ14Group::*setGeometricCombiningRules_function_type )( bool ) ;
setGeometricCombiningRules_function_type setGeometricCombiningRules_function_value( &::SireMM::CLJ14Group::setGeometricCombiningRules );
CLJ14Group_exposer.def(
"setGeometricCombiningRules"
, setGeometricCombiningRules_function_value
, ( bp::arg("on") ) );
}
{ //::SireMM::CLJ14Group::setStrict
typedef bool ( ::SireMM::CLJ14Group::*setStrict_function_type )( bool ) ;
setStrict_function_type setStrict_function_value( &::SireMM::CLJ14Group::setStrict );
CLJ14Group_exposer.def(
"setStrict"
, setStrict_function_value
, ( bp::arg("isstrict") ) );
}
{ //::SireMM::CLJ14Group::toString
typedef ::QString ( ::SireMM::CLJ14Group::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMM::CLJ14Group::toString );
CLJ14Group_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMM::CLJ14Group::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMM::CLJ14Group::typeName );
CLJ14Group_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMM::CLJ14Group::update
typedef void ( ::SireMM::CLJ14Group::*update_function_type )( ::SireMol::MoleculeView const & ) ;
update_function_type update_function_value( &::SireMM::CLJ14Group::update );
CLJ14Group_exposer.def(
"update"
, update_function_value
, ( bp::arg("new_molecule") ) );
}
{ //::SireMM::CLJ14Group::updateSelection
typedef void ( ::SireMM::CLJ14Group::*updateSelection_function_type )( ::SireMol::AtomSelection const & ) ;
updateSelection_function_type updateSelection_function_value( &::SireMM::CLJ14Group::updateSelection );
CLJ14Group_exposer.def(
"updateSelection"
, updateSelection_function_value
, ( bp::arg("selection") ) );
}
{ //::SireMM::CLJ14Group::usingArithmeticCombiningRules
typedef bool ( ::SireMM::CLJ14Group::*usingArithmeticCombiningRules_function_type )( ) const;
usingArithmeticCombiningRules_function_type usingArithmeticCombiningRules_function_value( &::SireMM::CLJ14Group::usingArithmeticCombiningRules );
CLJ14Group_exposer.def(
"usingArithmeticCombiningRules"
, usingArithmeticCombiningRules_function_value );
}
{ //::SireMM::CLJ14Group::usingGeometricCombiningRules
typedef bool ( ::SireMM::CLJ14Group::*usingGeometricCombiningRules_function_type )( ) const;
usingGeometricCombiningRules_function_type usingGeometricCombiningRules_function_value( &::SireMM::CLJ14Group::usingGeometricCombiningRules );
CLJ14Group_exposer.def(
"usingGeometricCombiningRules"
, usingGeometricCombiningRules_function_value );
}
{ //::SireMM::CLJ14Group::what
typedef char const * ( ::SireMM::CLJ14Group::*what_function_type )( ) const;
what_function_type what_function_value( &::SireMM::CLJ14Group::what );
CLJ14Group_exposer.def(
"what"
, what_function_value );
}
{ //::SireMM::CLJ14Group::wouldChangeProperties
typedef bool ( ::SireMM::CLJ14Group::*wouldChangeProperties_function_type )( ::SireBase::PropertyMap const & ) const;
wouldChangeProperties_function_type wouldChangeProperties_function_value( &::SireMM::CLJ14Group::wouldChangeProperties );
CLJ14Group_exposer.def(
"wouldChangeProperties"
, wouldChangeProperties_function_value
, ( bp::arg("map") ) );
}
CLJ14Group_exposer.staticmethod( "typeName" );
CLJ14Group_exposer.def( "__copy__", &__copy__);
CLJ14Group_exposer.def( "__deepcopy__", &__copy__);
CLJ14Group_exposer.def( "clone", &__copy__);
CLJ14Group_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::CLJ14Group >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CLJ14Group_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::CLJ14Group >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CLJ14Group_exposer.def( "__str__", &__str__< ::SireMM::CLJ14Group > );
CLJ14Group_exposer.def( "__repr__", &__str__< ::SireMM::CLJ14Group > );
}
}
void register_Ensemble_class(){
{ //::SireMove::Ensemble
typedef bp::class_< SireMove::Ensemble, bp::bases< SireBase::Property > > Ensemble_exposer_t;
Ensemble_exposer_t Ensemble_exposer = Ensemble_exposer_t( "Ensemble", "This class describes the ensemble that will be created by\na collection of moves (e.g. will the moves sample at constant\nvolume or temperature?)\n\nAuthor: Christopher Woods\n", bp::init< >("Construct an NVE ensemble") );
bp::scope Ensemble_scope( Ensemble_exposer );
Ensemble_exposer.def( bp::init< SireMove::Ensemble const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireMove::Ensemble::MuVT
typedef ::SireMove::Ensemble ( *MuVT_function_type )( ::SireUnits::Dimension::Temperature const &,::SireUnits::Dimension::Pressure const & );
MuVT_function_type MuVT_function_value( &::SireMove::Ensemble::MuVT );
Ensemble_exposer.def(
"MuVT"
, MuVT_function_value
, ( bp::arg("temperature"), bp::arg("fugacity") )
, "Return the MuVT ensemble for the temperature temperature and\nthe fugacity fugacity" );
}
{ //::SireMove::Ensemble::MuVT
typedef ::SireMove::Ensemble ( *MuVT_function_type )( ::SireUnits::Dimension::Temperature const &,::SireUnits::Dimension::MolarEnergy const & );
MuVT_function_type MuVT_function_value( &::SireMove::Ensemble::MuVT );
Ensemble_exposer.def(
"MuVT"
, MuVT_function_value
, ( bp::arg("temperature"), bp::arg("chemical_potential") )
, "Return the MuVT ensemble for the temperature temperature and\nthe chemical potential chemical_potential" );
}
{ //::SireMove::Ensemble::NPT
typedef ::SireMove::Ensemble ( *NPT_function_type )( ::SireUnits::Dimension::Temperature const &,::SireUnits::Dimension::Pressure const & );
NPT_function_type NPT_function_value( &::SireMove::Ensemble::NPT );
Ensemble_exposer.def(
"NPT"
, NPT_function_value
, ( bp::arg("temperature"), bp::arg("pressure") )
, "Return the NPT ensemble for the temperature temperature and\nthe pressure pressure" );
}
{ //::SireMove::Ensemble::NVE
typedef ::SireMove::Ensemble ( *NVE_function_type )( );
NVE_function_type NVE_function_value( &::SireMove::Ensemble::NVE );
Ensemble_exposer.def(
"NVE"
, NVE_function_value
, "Return the NVE ensemble" );
}
{ //::SireMove::Ensemble::NVT
typedef ::SireMove::Ensemble ( *NVT_function_type )( ::SireUnits::Dimension::Temperature const & );
NVT_function_type NVT_function_value( &::SireMove::Ensemble::NVT );
Ensemble_exposer.def(
"NVT"
, NVT_function_value
, ( bp::arg("temperature") )
, "Return the NVT ensemble for the temperature temperature" );
}
{ //::SireMove::Ensemble::canonical
typedef ::SireMove::Ensemble ( *canonical_function_type )( ::SireUnits::Dimension::Temperature const & );
canonical_function_type canonical_function_value( &::SireMove::Ensemble::canonical );
Ensemble_exposer.def(
"canonical"
, canonical_function_value
, ( bp::arg("temperature") )
, "Syntactic sugar to return the NVT ensemble" );
}
{ //::SireMove::Ensemble::chemicalPotential
typedef ::SireUnits::Dimension::MolarEnergy ( ::SireMove::Ensemble::*chemicalPotential_function_type)( ) const;
chemicalPotential_function_type chemicalPotential_function_value( &::SireMove::Ensemble::chemicalPotential );
Ensemble_exposer.def(
"chemicalPotential"
, chemicalPotential_function_value
, "Return the chemical potential of this ensemble\nThrow: SireError::incompatible_error\n" );
}
{ //::SireMove::Ensemble::fugacity
typedef ::SireUnits::Dimension::Pressure ( ::SireMove::Ensemble::*fugacity_function_type)( ) const;
fugacity_function_type fugacity_function_value( &::SireMove::Ensemble::fugacity );
Ensemble_exposer.def(
"fugacity"
, fugacity_function_value
, "Return the fugacity of this ensemble\nThrow: SireError::incompatible_error\n" );
}
{ //::SireMove::Ensemble::grandCanonical
typedef ::SireMove::Ensemble ( *grandCanonical_function_type )( ::SireUnits::Dimension::Temperature const &,::SireUnits::Dimension::Pressure const & );
grandCanonical_function_type grandCanonical_function_value( &::SireMove::Ensemble::grandCanonical );
Ensemble_exposer.def(
"grandCanonical"
, grandCanonical_function_value
, ( bp::arg("temperature"), bp::arg("fugacity") )
, "Syntactic sugar to return the MuVT ensemble" );
}
{ //::SireMove::Ensemble::grandCanonical
typedef ::SireMove::Ensemble ( *grandCanonical_function_type )( ::SireUnits::Dimension::Temperature const &,::SireUnits::Dimension::MolarEnergy const & );
grandCanonical_function_type grandCanonical_function_value( &::SireMove::Ensemble::grandCanonical );
Ensemble_exposer.def(
"grandCanonical"
, grandCanonical_function_value
, ( bp::arg("temperature"), bp::arg("chemical_potential") )
, "Syntactic sugar to return the MuVT ensemble" );
}
{ //::SireMove::Ensemble::isCanonical
typedef bool ( ::SireMove::Ensemble::*isCanonical_function_type)( ) const;
isCanonical_function_type isCanonical_function_value( &::SireMove::Ensemble::isCanonical );
Ensemble_exposer.def(
"isCanonical"
, isCanonical_function_value
, "Return whether or not this is the canonical (NVT) ensemble" );
}
{ //::SireMove::Ensemble::isConstantChemicalPotential
typedef bool ( ::SireMove::Ensemble::*isConstantChemicalPotential_function_type)( ) const;
isConstantChemicalPotential_function_type isConstantChemicalPotential_function_value( &::SireMove::Ensemble::isConstantChemicalPotential );
Ensemble_exposer.def(
"isConstantChemicalPotential"
, isConstantChemicalPotential_function_value
, "Return whether the chemical potential is constant in this ensemble" );
}
{ //::SireMove::Ensemble::isConstantEnergy
typedef bool ( ::SireMove::Ensemble::*isConstantEnergy_function_type)( ) const;
isConstantEnergy_function_type isConstantEnergy_function_value( &::SireMove::Ensemble::isConstantEnergy );
Ensemble_exposer.def(
"isConstantEnergy"
, isConstantEnergy_function_value
, "Return whether or not energy is a constant in this ensemble" );
}
{ //::SireMove::Ensemble::isConstantFugacity
typedef bool ( ::SireMove::Ensemble::*isConstantFugacity_function_type)( ) const;
isConstantFugacity_function_type isConstantFugacity_function_value( &::SireMove::Ensemble::isConstantFugacity );
Ensemble_exposer.def(
"isConstantFugacity"
, isConstantFugacity_function_value
, "Return whether the chemical potential is constant in this ensemble" );
}
{ //::SireMove::Ensemble::isConstantNParticles
typedef bool ( ::SireMove::Ensemble::*isConstantNParticles_function_type)( ) const;
isConstantNParticles_function_type isConstantNParticles_function_value( &::SireMove::Ensemble::isConstantNParticles );
Ensemble_exposer.def(
"isConstantNParticles"
, isConstantNParticles_function_value
, "Return whether or not the number of particles is constant in this ensemble" );
}
{ //::SireMove::Ensemble::isConstantPressure
typedef bool ( ::SireMove::Ensemble::*isConstantPressure_function_type)( ) const;
isConstantPressure_function_type isConstantPressure_function_value( &::SireMove::Ensemble::isConstantPressure );
Ensemble_exposer.def(
"isConstantPressure"
, isConstantPressure_function_value
, "Return whether or not pressure is a constant in this ensemble" );
}
{ //::SireMove::Ensemble::isConstantTemperature
typedef bool ( ::SireMove::Ensemble::*isConstantTemperature_function_type)( ) const;
isConstantTemperature_function_type isConstantTemperature_function_value( &::SireMove::Ensemble::isConstantTemperature );
Ensemble_exposer.def(
"isConstantTemperature"
, isConstantTemperature_function_value
, "Return whether or not temperature is a constant in this ensemble" );
}
{ //::SireMove::Ensemble::isConstantVolume
typedef bool ( ::SireMove::Ensemble::*isConstantVolume_function_type)( ) const;
isConstantVolume_function_type isConstantVolume_function_value( &::SireMove::Ensemble::isConstantVolume );
Ensemble_exposer.def(
"isConstantVolume"
, isConstantVolume_function_value
, "Return whether or not volume is a constant in this ensemble" );
}
{ //::SireMove::Ensemble::isGrandCanonical
typedef bool ( ::SireMove::Ensemble::*isGrandCanonical_function_type)( ) const;
isGrandCanonical_function_type isGrandCanonical_function_value( &::SireMove::Ensemble::isGrandCanonical );
Ensemble_exposer.def(
"isGrandCanonical"
, isGrandCanonical_function_value
, "Return whether or not this is the grand canonical (MuVT) ensemble" );
}
{ //::SireMove::Ensemble::isIsothermalIsobaric
typedef bool ( ::SireMove::Ensemble::*isIsothermalIsobaric_function_type)( ) const;
isIsothermalIsobaric_function_type isIsothermalIsobaric_function_value( &::SireMove::Ensemble::isIsothermalIsobaric );
Ensemble_exposer.def(
"isIsothermalIsobaric"
, isIsothermalIsobaric_function_value
, "Return whether or not this is the isothermal-isobaric (NPT) ensemble" );
}
{ //::SireMove::Ensemble::isMicroCanonical
typedef bool ( ::SireMove::Ensemble::*isMicroCanonical_function_type)( ) const;
isMicroCanonical_function_type isMicroCanonical_function_value( &::SireMove::Ensemble::isMicroCanonical );
Ensemble_exposer.def(
"isMicroCanonical"
, isMicroCanonical_function_value
, "Return whether or not this is the microcanonical (NVE) ensemble" );
}
{ //::SireMove::Ensemble::isMuVT
typedef bool ( ::SireMove::Ensemble::*isMuVT_function_type)( ) const;
isMuVT_function_type isMuVT_function_value( &::SireMove::Ensemble::isMuVT );
Ensemble_exposer.def(
"isMuVT"
, isMuVT_function_value
, "Return whether or not this is the MuVT ensemble" );
}
{ //::SireMove::Ensemble::isNPT
typedef bool ( ::SireMove::Ensemble::*isNPT_function_type)( ) const;
isNPT_function_type isNPT_function_value( &::SireMove::Ensemble::isNPT );
Ensemble_exposer.def(
"isNPT"
, isNPT_function_value
, "Return whether or not this is the NPT ensemble" );
}
{ //::SireMove::Ensemble::isNVE
typedef bool ( ::SireMove::Ensemble::*isNVE_function_type)( ) const;
isNVE_function_type isNVE_function_value( &::SireMove::Ensemble::isNVE );
Ensemble_exposer.def(
"isNVE"
, isNVE_function_value
, "Return whether or not this is the NVE ensemble" );
}
{ //::SireMove::Ensemble::isNVT
typedef bool ( ::SireMove::Ensemble::*isNVT_function_type)( ) const;
isNVT_function_type isNVT_function_value( &::SireMove::Ensemble::isNVT );
Ensemble_exposer.def(
"isNVT"
, isNVT_function_value
, "Return whether or not this is the NVT ensemble" );
}
{ //::SireMove::Ensemble::isothermalIsobaric
typedef ::SireMove::Ensemble ( *isothermalIsobaric_function_type )( ::SireUnits::Dimension::Temperature const &,::SireUnits::Dimension::Pressure const & );
isothermalIsobaric_function_type isothermalIsobaric_function_value( &::SireMove::Ensemble::isothermalIsobaric );
Ensemble_exposer.def(
"isothermalIsobaric"
, isothermalIsobaric_function_value
, ( bp::arg("temperature"), bp::arg("pressure") )
, "Syntactic sugar to return the NPT ensemble" );
}
{ //::SireMove::Ensemble::merge
typedef ::SireMove::Ensemble ( ::SireMove::Ensemble::*merge_function_type)( ::SireMove::Ensemble const & ) const;
merge_function_type merge_function_value( &::SireMove::Ensemble::merge );
Ensemble_exposer.def(
"merge"
, merge_function_value
, ( bp::arg("other") )
, "Merge this ensemble with other. This tries to find an ensemble\nthat satisfies both, e.g. merging NVE with NVT will give NVT,\nwhile merging NVE with NPT would give NPT." );
}
{ //::SireMove::Ensemble::merge
typedef ::SireMove::Ensemble ( *merge_function_type )( ::SireMove::Ensemble const &,::SireMove::Ensemble const & );
merge_function_type merge_function_value( &::SireMove::Ensemble::merge );
Ensemble_exposer.def(
"merge"
, merge_function_value
, ( bp::arg("e0"), bp::arg("e1") )
, "Merge the two ensembles e0 and e1 together. This tries to find an ensemble\nthat satisfies both, e.g. merging NVE with NVT will give NVT,\nwhile merging NVE with NPT would give NPT." );
}
{ //::SireMove::Ensemble::microcanonical
typedef ::SireMove::Ensemble ( *microcanonical_function_type )( );
microcanonical_function_type microcanonical_function_value( &::SireMove::Ensemble::microcanonical );
Ensemble_exposer.def(
"microcanonical"
, microcanonical_function_value
, "Syntactic sugar to return the NVE ensemble" );
}
{ //::SireMove::Ensemble::name
typedef ::QString ( ::SireMove::Ensemble::*name_function_type)( ) const;
name_function_type name_function_value( &::SireMove::Ensemble::name );
Ensemble_exposer.def(
"name"
, name_function_value
, "Return the name of this ensemble (if it has a name)" );
}
Ensemble_exposer.def( bp::self != bp::self );
{ //::SireMove::Ensemble::operator=
typedef ::SireMove::Ensemble & ( ::SireMove::Ensemble::*assign_function_type)( ::SireMove::Ensemble const & ) ;
assign_function_type assign_function_value( &::SireMove::Ensemble::operator= );
Ensemble_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
Ensemble_exposer.def( bp::self == bp::self );
{ //::SireMove::Ensemble::pressure
typedef ::SireUnits::Dimension::Pressure ( ::SireMove::Ensemble::*pressure_function_type)( ) const;
pressure_function_type pressure_function_value( &::SireMove::Ensemble::pressure );
Ensemble_exposer.def(
"pressure"
, pressure_function_value
, "Return the pressure of this ensemble\nThrow: SireError::incompatible_error\n" );
}
{ //::SireMove::Ensemble::shortHand
typedef ::QString ( ::SireMove::Ensemble::*shortHand_function_type)( ) const;
shortHand_function_type shortHand_function_value( &::SireMove::Ensemble::shortHand );
Ensemble_exposer.def(
"shortHand"
, shortHand_function_value
, "Return the shorthand string for this ensemble (e.g. NVT)" );
}
{ //::SireMove::Ensemble::temperature
typedef ::SireUnits::Dimension::Temperature ( ::SireMove::Ensemble::*temperature_function_type)( ) const;
temperature_function_type temperature_function_value( &::SireMove::Ensemble::temperature );
Ensemble_exposer.def(
"temperature"
, temperature_function_value
, "Return the temperature of this ensemble\nThrow: SireError::incompatible_error\n" );
}
{ //::SireMove::Ensemble::toString
typedef ::QString ( ::SireMove::Ensemble::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMove::Ensemble::toString );
Ensemble_exposer.def(
"toString"
, toString_function_value
, "Return a string representation of this ensemble" );
}
{ //::SireMove::Ensemble::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMove::Ensemble::typeName );
Ensemble_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
Ensemble_exposer.staticmethod( "MuVT" );
Ensemble_exposer.staticmethod( "NPT" );
Ensemble_exposer.staticmethod( "NVE" );
Ensemble_exposer.staticmethod( "NVT" );
Ensemble_exposer.staticmethod( "canonical" );
Ensemble_exposer.staticmethod( "grandCanonical" );
Ensemble_exposer.staticmethod( "isothermalIsobaric" );
Ensemble_exposer.staticmethod( "merge" );
Ensemble_exposer.staticmethod( "microcanonical" );
Ensemble_exposer.staticmethod( "typeName" );
Ensemble_exposer.def( "__copy__", &__copy__);
Ensemble_exposer.def( "__deepcopy__", &__copy__);
Ensemble_exposer.def( "clone", &__copy__);
Ensemble_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMove::Ensemble >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Ensemble_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMove::Ensemble >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Ensemble_exposer.def( "__str__", &__str__< ::SireMove::Ensemble > );
Ensemble_exposer.def( "__repr__", &__str__< ::SireMove::Ensemble > );
}
}
void register_TrigArray2D_double__class(){
{ //::SireBase::TrigArray2D< double >
typedef bp::class_< SireBase::TrigArray2D< double >, bp::bases< SireBase::TrigArray2DBase > > TrigArray2D_double__exposer_t;
TrigArray2D_double__exposer_t TrigArray2D_double__exposer = TrigArray2D_double__exposer_t( "TrigArray2D_double_", bp::init< >() );
bp::scope TrigArray2D_double__scope( TrigArray2D_double__exposer );
TrigArray2D_double__exposer.def( bp::init< int >(( bp::arg("dimension") )) );
TrigArray2D_double__exposer.def( bp::init< int, double const & >(( bp::arg("dimension"), bp::arg("default_value") )) );
TrigArray2D_double__exposer.def( bp::init< SireBase::TrigArray2D< double > const & >(( bp::arg("other") )) );
{ //::SireBase::TrigArray2D< double >::at
typedef SireBase::TrigArray2D< double > exported_class_t;
typedef double const & ( ::SireBase::TrigArray2D< double >::*at_function_type )( int,int ) const;
at_function_type at_function_value( &::SireBase::TrigArray2D< double >::at );
TrigArray2D_double__exposer.def(
"at"
, at_function_value
, ( bp::arg("i"), bp::arg("j") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireBase::TrigArray2D< double >::get
typedef SireBase::TrigArray2D< double > exported_class_t;
typedef double const & ( ::SireBase::TrigArray2D< double >::*get_function_type )( int,int ) const;
get_function_type get_function_value( &::SireBase::TrigArray2D< double >::get );
TrigArray2D_double__exposer.def(
"get"
, get_function_value
, ( bp::arg("i"), bp::arg("j") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
TrigArray2D_double__exposer.def( bp::self != bp::self );
{ //::SireBase::TrigArray2D< double >::operator()
typedef SireBase::TrigArray2D< double > exported_class_t;
typedef double const & ( ::SireBase::TrigArray2D< double >::*__call___function_type )( int,int ) const;
__call___function_type __call___function_value( &::SireBase::TrigArray2D< double >::operator() );
TrigArray2D_double__exposer.def(
"__call__"
, __call___function_value
, ( bp::arg("i"), bp::arg("j") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireBase::TrigArray2D< double >::operator=
typedef SireBase::TrigArray2D< double > exported_class_t;
typedef ::SireBase::TrigArray2D< double > & ( ::SireBase::TrigArray2D< double >::*assign_function_type )( ::SireBase::TrigArray2D< double > const & ) ;
assign_function_type assign_function_value( &::SireBase::TrigArray2D< double >::operator= );
TrigArray2D_double__exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
TrigArray2D_double__exposer.def( bp::self == bp::self );
{ //::SireBase::TrigArray2D< double >::redimension
typedef SireBase::TrigArray2D< double > exported_class_t;
typedef void ( ::SireBase::TrigArray2D< double >::*redimension_function_type )( int ) ;
redimension_function_type redimension_function_value( &::SireBase::TrigArray2D< double >::redimension );
TrigArray2D_double__exposer.def(
"redimension"
, redimension_function_value
, ( bp::arg("dimension") ) );
}
{ //::SireBase::TrigArray2D< double >::set
typedef SireBase::TrigArray2D< double > exported_class_t;
typedef void ( ::SireBase::TrigArray2D< double >::*set_function_type )( int,int,double const & ) ;
set_function_type set_function_value( &::SireBase::TrigArray2D< double >::set );
TrigArray2D_double__exposer.def(
"set"
, set_function_value
, ( bp::arg("i"), bp::arg("j"), bp::arg("value") ) );
}
{ //::SireBase::TrigArray2D< double >::setAll
typedef SireBase::TrigArray2D< double > exported_class_t;
typedef void ( ::SireBase::TrigArray2D< double >::*setAll_function_type )( double const & ) ;
setAll_function_type setAll_function_value( &::SireBase::TrigArray2D< double >::setAll );
TrigArray2D_double__exposer.def(
"setAll"
, setAll_function_value
, ( bp::arg("value") ) );
}
{ //::SireBase::TrigArray2D< double >::toString
typedef SireBase::TrigArray2D< double > exported_class_t;
typedef ::QString ( ::SireBase::TrigArray2D< double >::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireBase::TrigArray2D< double >::toString );
TrigArray2D_double__exposer.def(
"toString"
, toString_function_value );
}
{ //::SireBase::TrigArray2D< double >::transpose
typedef SireBase::TrigArray2D< double > exported_class_t;
typedef ::SireBase::TrigArray2D< double > ( ::SireBase::TrigArray2D< double >::*transpose_function_type )( ) const;
transpose_function_type transpose_function_value( &::SireBase::TrigArray2D< double >::transpose );
TrigArray2D_double__exposer.def(
"transpose"
, transpose_function_value );
}
TrigArray2D_double__exposer.def( "__copy__", &__copy__);
TrigArray2D_double__exposer.def( "__deepcopy__", &__copy__);
TrigArray2D_double__exposer.def( "clone", &__copy__);
TrigArray2D_double__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::TrigArray2D<double> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
TrigArray2D_double__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::TrigArray2D<double> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
TrigArray2D_double__exposer.def( "__str__", &__str__< ::SireBase::TrigArray2D<double> > );
TrigArray2D_double__exposer.def( "__repr__", &__str__< ::SireBase::TrigArray2D<double> > );
TrigArray2D_double__exposer.def( "__len__", &__len_size< ::SireBase::TrigArray2D<double> > );
}
}
void register_Integrator_class(){
{ //::SireMove::Integrator
typedef bp::class_< SireMove::Integrator, bp::bases< SireBase::Property >, boost::noncopyable > Integrator_exposer_t;
Integrator_exposer_t Integrator_exposer = Integrator_exposer_t( "Integrator", "This is the virtual base class of all dynamics integrators. An integrator\nis the kernel used to advance the coordinates of the system from one\ntimestep to the next\n\nAuthor: Christopher Woods\n", bp::no_init );
bp::scope Integrator_scope( Integrator_exposer );
{ //::SireMove::Integrator::createWorkspace
typedef ::SireMove::IntegratorWorkspacePtr ( ::SireMove::Integrator::*createWorkspace_function_type)( ::SireBase::PropertyMap const & ) const;
createWorkspace_function_type createWorkspace_function_value( &::SireMove::Integrator::createWorkspace );
Integrator_exposer.def(
"createWorkspace"
, createWorkspace_function_value
, ( bp::arg("map")=SireBase::PropertyMap() )
, "" );
}
{ //::SireMove::Integrator::createWorkspace
typedef ::SireMove::IntegratorWorkspacePtr ( ::SireMove::Integrator::*createWorkspace_function_type)( ::SireMol::MoleculeGroup const &,::SireBase::PropertyMap const & ) const;
createWorkspace_function_type createWorkspace_function_value( &::SireMove::Integrator::createWorkspace );
Integrator_exposer.def(
"createWorkspace"
, createWorkspace_function_value
, ( bp::arg("molgroup"), bp::arg("map")=SireBase::PropertyMap() )
, "" );
}
{ //::SireMove::Integrator::ensemble
typedef ::SireMove::Ensemble ( ::SireMove::Integrator::*ensemble_function_type)( ) const;
ensemble_function_type ensemble_function_value( &::SireMove::Integrator::ensemble );
Integrator_exposer.def(
"ensemble"
, ensemble_function_value
, "" );
}
{ //::SireMove::Integrator::integrate
typedef void ( ::SireMove::Integrator::*integrate_function_type)( ::SireMove::IntegratorWorkspace &,::SireCAS::Symbol const &,::SireUnits::Dimension::Time,int,bool ) ;
integrate_function_type integrate_function_value( &::SireMove::Integrator::integrate );
Integrator_exposer.def(
"integrate"
, integrate_function_value
, ( bp::arg("workspace"), bp::arg("nrg_component"), bp::arg("timestep"), bp::arg("nmoves"), bp::arg("record_stats") )
, "" );
}
{ //::SireMove::Integrator::isTimeReversible
typedef bool ( ::SireMove::Integrator::*isTimeReversible_function_type)( ) const;
isTimeReversible_function_type isTimeReversible_function_value( &::SireMove::Integrator::isTimeReversible );
Integrator_exposer.def(
"isTimeReversible"
, isTimeReversible_function_value
, "" );
}
{ //::SireMove::Integrator::null
typedef ::SireMove::NullIntegrator const & ( *null_function_type )( );
null_function_type null_function_value( &::SireMove::Integrator::null );
Integrator_exposer.def(
"null"
, null_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "Return a NullIntegrator" );
}
{ //::SireMove::Integrator::toString
typedef ::QString ( ::SireMove::Integrator::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMove::Integrator::toString );
Integrator_exposer.def(
"toString"
, toString_function_value
, "" );
}
{ //::SireMove::Integrator::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMove::Integrator::typeName );
Integrator_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
Integrator_exposer.staticmethod( "null" );
Integrator_exposer.staticmethod( "typeName" );
Integrator_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMove::Integrator >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Integrator_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMove::Integrator >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Integrator_exposer.def( "__str__", &__str__< ::SireMove::Integrator > );
Integrator_exposer.def( "__repr__", &__str__< ::SireMove::Integrator > );
}
}
void register_BeadEditor_class(){
{ //::SireMol::BeadEditor
typedef bp::class_< SireMol::BeadEditor, bp::bases< SireMol::Editor<SireMol::BeadEditor, SireMol::Bead>, SireMol::Bead, SireMol::MoleculeView, SireBase::Property > > BeadEditor_exposer_t;
BeadEditor_exposer_t BeadEditor_exposer = BeadEditor_exposer_t( "BeadEditor", "This is an editor for a single bead in a molecule\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") );
bp::scope BeadEditor_scope( BeadEditor_exposer );
BeadEditor_exposer.def( bp::init< SireMol::Bead const & >(( bp::arg("bead") ), "Constructor an editor for the passed bead") );
BeadEditor_exposer.def( bp::init< SireMol::BeadEditor const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireMol::BeadEditor::commit
typedef ::SireMol::Bead ( ::SireMol::BeadEditor::*commit_function_type)( ) const;
commit_function_type commit_function_value( &::SireMol::BeadEditor::commit );
BeadEditor_exposer.def(
"commit"
, commit_function_value
, "Commit the changes" );
}
{ //::SireMol::BeadEditor::operator=
typedef ::SireMol::BeadEditor & ( ::SireMol::BeadEditor::*assign_function_type)( ::SireMol::Bead const & ) ;
assign_function_type assign_function_value( &::SireMol::BeadEditor::operator= );
BeadEditor_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("bead") )
, bp::return_self< >()
, "" );
}
{ //::SireMol::BeadEditor::operator=
typedef ::SireMol::BeadEditor & ( ::SireMol::BeadEditor::*assign_function_type)( ::SireMol::BeadEditor const & ) ;
assign_function_type assign_function_value( &::SireMol::BeadEditor::operator= );
BeadEditor_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
{ //::SireMol::BeadEditor::toString
typedef ::QString ( ::SireMol::BeadEditor::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMol::BeadEditor::toString );
BeadEditor_exposer.def(
"toString"
, toString_function_value
, "Return a string representation of this editor" );
}
{ //::SireMol::BeadEditor::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::BeadEditor::typeName );
BeadEditor_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
BeadEditor_exposer.staticmethod( "typeName" );
BeadEditor_exposer.def( "__copy__", &__copy__);
BeadEditor_exposer.def( "__deepcopy__", &__copy__);
BeadEditor_exposer.def( "clone", &__copy__);
BeadEditor_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::BeadEditor >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
BeadEditor_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::BeadEditor >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
BeadEditor_exposer.def( "__str__", &__str__< ::SireMol::BeadEditor > );
BeadEditor_exposer.def( "__repr__", &__str__< ::SireMol::BeadEditor > );
BeadEditor_exposer.def( "__len__", &__len_size< ::SireMol::BeadEditor > );
}
}
void register_Specify_SegID__class(){
{ //::SireID::Specify< SireMol::SegID >
typedef bp::class_< SireID::Specify< SireMol::SegID >, bp::bases< SireMol::SegID, SireID::ID > > Specify_SegID__exposer_t;
Specify_SegID__exposer_t Specify_SegID__exposer = Specify_SegID__exposer_t( "Specify_SegID_", bp::init< >() );
bp::scope Specify_SegID__scope( Specify_SegID__exposer );
Specify_SegID__exposer.def( bp::init< SireMol::SegID const &, qint32 >(( bp::arg("id"), bp::arg("i") )) );
Specify_SegID__exposer.def( bp::init< SireMol::SegID const &, qint32, qint32 >(( bp::arg("id"), bp::arg("i"), bp::arg("j") )) );
Specify_SegID__exposer.def( bp::init< SireID::Specify< SireMol::SegID > const & >(( bp::arg("other") )) );
{ //::SireID::Specify< SireMol::SegID >::hash
typedef SireID::Specify< SireMol::SegID > exported_class_t;
typedef ::uint ( ::SireID::Specify< SireMol::SegID >::*hash_function_type )( ) const;
hash_function_type hash_function_value( &::SireID::Specify< SireMol::SegID >::hash );
Specify_SegID__exposer.def(
"hash"
, hash_function_value );
}
{ //::SireID::Specify< SireMol::SegID >::isNull
typedef SireID::Specify< SireMol::SegID > exported_class_t;
typedef bool ( ::SireID::Specify< SireMol::SegID >::*isNull_function_type )( ) const;
isNull_function_type isNull_function_value( &::SireID::Specify< SireMol::SegID >::isNull );
Specify_SegID__exposer.def(
"isNull"
, isNull_function_value );
}
{ //::SireID::Specify< SireMol::SegID >::map
typedef SireID::Specify< SireMol::SegID > exported_class_t;
typedef ::QList< SireMol::SegIdx > ( ::SireID::Specify< SireMol::SegID >::*map_function_type )( ::SireMol::MolInfo const & ) const;
map_function_type map_function_value( &::SireID::Specify< SireMol::SegID >::map );
Specify_SegID__exposer.def(
"map"
, map_function_value
, ( bp::arg("obj") ) );
}
Specify_SegID__exposer.def( bp::self != bp::self );
Specify_SegID__exposer.def( bp::self != bp::other< SireID::ID >() );
{ //::SireID::Specify< SireMol::SegID >::operator()
typedef SireID::Specify< SireMol::SegID > exported_class_t;
typedef ::SireID::Specify< SireMol::SegID > ( ::SireID::Specify< SireMol::SegID >::*__call___function_type )( int ) const;
__call___function_type __call___function_value( &::SireID::Specify< SireMol::SegID >::operator() );
Specify_SegID__exposer.def(
"__call__"
, __call___function_value
, ( bp::arg("i") ) );
}
{ //::SireID::Specify< SireMol::SegID >::operator()
typedef SireID::Specify< SireMol::SegID > exported_class_t;
typedef ::SireID::Specify< SireMol::SegID > ( ::SireID::Specify< SireMol::SegID >::*__call___function_type )( int,int ) const;
__call___function_type __call___function_value( &::SireID::Specify< SireMol::SegID >::operator() );
Specify_SegID__exposer.def(
"__call__"
, __call___function_value
, ( bp::arg("i"), bp::arg("j") ) );
}
{ //::SireID::Specify< SireMol::SegID >::operator=
typedef SireID::Specify< SireMol::SegID > exported_class_t;
typedef ::SireID::Specify< SireMol::SegID > & ( ::SireID::Specify< SireMol::SegID >::*assign_function_type )( ::SireID::Specify< SireMol::SegID > const & ) ;
assign_function_type assign_function_value( &::SireID::Specify< SireMol::SegID >::operator= );
Specify_SegID__exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
Specify_SegID__exposer.def( bp::self == bp::self );
Specify_SegID__exposer.def( bp::self == bp::other< SireID::ID >() );
{ //::SireID::Specify< SireMol::SegID >::operator[]
typedef SireID::Specify< SireMol::SegID > exported_class_t;
typedef ::SireID::Specify< SireMol::SegID > ( ::SireID::Specify< SireMol::SegID >::*__getitem___function_type )( int ) const;
__getitem___function_type __getitem___function_value( &::SireID::Specify< SireMol::SegID >::operator[] );
Specify_SegID__exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") ) );
}
{ //::SireID::Specify< SireMol::SegID >::toString
typedef SireID::Specify< SireMol::SegID > exported_class_t;
typedef ::QString ( ::SireID::Specify< SireMol::SegID >::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireID::Specify< SireMol::SegID >::toString );
Specify_SegID__exposer.def(
"toString"
, toString_function_value );
}
{ //::SireID::Specify< SireMol::SegID >::typeName
typedef SireID::Specify< SireMol::SegID > exported_class_t;
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireID::Specify< SireMol::SegID >::typeName );
Specify_SegID__exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireID::Specify< SireMol::SegID >::what
typedef SireID::Specify< SireMol::SegID > exported_class_t;
typedef char const * ( ::SireID::Specify< SireMol::SegID >::*what_function_type )( ) const;
what_function_type what_function_value( &::SireID::Specify< SireMol::SegID >::what );
Specify_SegID__exposer.def(
"what"
, what_function_value );
}
Specify_SegID__exposer.staticmethod( "typeName" );
Specify_SegID__exposer.def( "__copy__", &__copy__);
Specify_SegID__exposer.def( "__deepcopy__", &__copy__);
Specify_SegID__exposer.def( "clone", &__copy__);
Specify_SegID__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireID::Specify<SireMol::SegID> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Specify_SegID__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireID::Specify<SireMol::SegID> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Specify_SegID__exposer.def( "__str__", &__str__< ::SireID::Specify<SireMol::SegID> > );
Specify_SegID__exposer.def( "__repr__", &__str__< ::SireID::Specify<SireMol::SegID> > );
}
}
void register_LJPerturbation_class(){
{ //::SireMM::LJPerturbation
typedef bp::class_< SireMM::LJPerturbation, bp::bases< SireMol::Perturbation, SireBase::Property > > LJPerturbation_exposer_t;
LJPerturbation_exposer_t LJPerturbation_exposer = LJPerturbation_exposer_t( "LJPerturbation", "This is a perturbation that maps LJ parameters for a molecule\nfrom an initial to a final state\n\nAuthor: Christopher Woods\n", bp::init< bp::optional< SireBase::PropertyMap const & > >(( bp::arg("map")=SireBase::PropertyMap() ), "Constructor - this creates a LJ perturbation that\nperturbs from LJs in initial_LJ to LJs in\nfinal_LJ, placing the current LJs in LJ,\nand using Perturbation::defaultEquation() to map the\nsigma and epsilon values of the LJ.") );
bp::scope LJPerturbation_scope( LJPerturbation_exposer );
bp::enum_< SireMM::LJPerturbation::MapType>("MapType")
.value("MAP_SIGMA_AND_EPSILON", SireMM::LJPerturbation::MAP_SIGMA_AND_EPSILON)
.value("MAP_RMIN_AND_EPSILON", SireMM::LJPerturbation::MAP_RMIN_AND_EPSILON)
.value("MAP_A_AND_B", SireMM::LJPerturbation::MAP_A_AND_B)
.export_values()
;
LJPerturbation_exposer.def( bp::init< SireMM::LJPerturbation::MapType, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("maptype"), bp::arg("map")=SireBase::PropertyMap() ), "Construct, using the passed map to find the properties used\nby this perturbation") );
LJPerturbation_exposer.def( bp::init< SireCAS::Expression const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("mapping_function"), bp::arg("map")=SireBase::PropertyMap() ), "Construct, using the passed map to find the properties used\nby this perturbation and the passed mapping function to map\nthe LJs between the states") );
LJPerturbation_exposer.def( bp::init< SireCAS::Expression const &, SireMM::LJPerturbation::MapType, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("mapping_function"), bp::arg("maptype"), bp::arg("map")=SireBase::PropertyMap() ), "Construct, using the passed map to find the properties used\nby this perturbation and the passed mapping function to map\nthe LJs between the states") );
LJPerturbation_exposer.def( bp::init< SireCAS::Expression const &, SireCAS::Expression const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("sigma_mapping_function"), bp::arg("epsilon_mapping_function"), bp::arg("map")=SireBase::PropertyMap() ), "Construct, using the passed map to find the properties used\nby this perturbation and the passed mapping function to map\nthe LJs between the states") );
LJPerturbation_exposer.def( bp::init< SireCAS::Expression const &, SireCAS::Expression const &, SireMM::LJPerturbation::MapType, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("sigma_mapping_function"), bp::arg("epsilon_mapping_function"), bp::arg("maptype"), bp::arg("map")=SireBase::PropertyMap() ), "Construct, using the passed map to find the properties used\nby this perturbation and the passed mapping function to map\nthe LJs between the states") );
LJPerturbation_exposer.def( bp::init< SireMM::LJPerturbation const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireMM::LJPerturbation::A_MappingFunction
typedef ::SireCAS::Expression const & ( ::SireMM::LJPerturbation::*A_MappingFunction_function_type)( ) const;
A_MappingFunction_function_type A_MappingFunction_function_value( &::SireMM::LJPerturbation::A_MappingFunction );
LJPerturbation_exposer.def(
"A_MappingFunction"
, A_MappingFunction_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the function used to map A\nThrow: SireError::invalid_state\n" );
}
{ //::SireMM::LJPerturbation::B_MappingFunction
typedef ::SireCAS::Expression const & ( ::SireMM::LJPerturbation::*B_MappingFunction_function_type)( ) const;
B_MappingFunction_function_type B_MappingFunction_function_value( &::SireMM::LJPerturbation::B_MappingFunction );
LJPerturbation_exposer.def(
"B_MappingFunction"
, B_MappingFunction_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the function used to map B\nThrow: SireError::invalid_state\n" );
}
{ //::SireMM::LJPerturbation::epsilonMappingFunction
typedef ::SireCAS::Expression const & ( ::SireMM::LJPerturbation::*epsilonMappingFunction_function_type)( ) const;
epsilonMappingFunction_function_type epsilonMappingFunction_function_value( &::SireMM::LJPerturbation::epsilonMappingFunction );
LJPerturbation_exposer.def(
"epsilonMappingFunction"
, epsilonMappingFunction_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the function used to map epsilon\nThrow: SireError::invalid_state\n" );
}
{ //::SireMM::LJPerturbation::mapAB
typedef bool ( ::SireMM::LJPerturbation::*mapAB_function_type)( ) const;
mapAB_function_type mapAB_function_value( &::SireMM::LJPerturbation::mapAB );
LJPerturbation_exposer.def(
"mapAB"
, mapAB_function_value
, "Return whether or not this maps A and B" );
}
{ //::SireMM::LJPerturbation::mapRMinEpsilon
typedef bool ( ::SireMM::LJPerturbation::*mapRMinEpsilon_function_type)( ) const;
mapRMinEpsilon_function_type mapRMinEpsilon_function_value( &::SireMM::LJPerturbation::mapRMinEpsilon );
LJPerturbation_exposer.def(
"mapRMinEpsilon"
, mapRMinEpsilon_function_value
, "Return whether or not this maps r_min and epsilon" );
}
{ //::SireMM::LJPerturbation::mapSigmaEpsilon
typedef bool ( ::SireMM::LJPerturbation::*mapSigmaEpsilon_function_type)( ) const;
mapSigmaEpsilon_function_type mapSigmaEpsilon_function_value( &::SireMM::LJPerturbation::mapSigmaEpsilon );
LJPerturbation_exposer.def(
"mapSigmaEpsilon"
, mapSigmaEpsilon_function_value
, "Return whether or not this maps sigma and epsilon" );
}
{ //::SireMM::LJPerturbation::mappingFunction
typedef ::SireCAS::Expression const & ( ::SireMM::LJPerturbation::*mappingFunction_function_type)( ) const;
mappingFunction_function_type mappingFunction_function_value( &::SireMM::LJPerturbation::mappingFunction );
LJPerturbation_exposer.def(
"mappingFunction"
, mappingFunction_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the mapping function\nThrow: SireError::invalid_state\n" );
}
LJPerturbation_exposer.def( bp::self != bp::self );
{ //::SireMM::LJPerturbation::operator=
typedef ::SireMM::LJPerturbation & ( ::SireMM::LJPerturbation::*assign_function_type)( ::SireMM::LJPerturbation const & ) ;
assign_function_type assign_function_value( &::SireMM::LJPerturbation::operator= );
LJPerturbation_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
LJPerturbation_exposer.def( bp::self == bp::self );
{ //::SireMM::LJPerturbation::rMinMappingFunction
typedef ::SireCAS::Expression const & ( ::SireMM::LJPerturbation::*rMinMappingFunction_function_type)( ) const;
rMinMappingFunction_function_type rMinMappingFunction_function_value( &::SireMM::LJPerturbation::rMinMappingFunction );
LJPerturbation_exposer.def(
"rMinMappingFunction"
, rMinMappingFunction_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the function used to map r_min\nThrow: SireError::invalid_state\n" );
}
{ //::SireMM::LJPerturbation::recreate
typedef ::SireMol::PerturbationPtr ( ::SireMM::LJPerturbation::*recreate_function_type)( ::SireCAS::Expression const & ) const;
recreate_function_type recreate_function_value( &::SireMM::LJPerturbation::recreate );
LJPerturbation_exposer.def(
"recreate"
, recreate_function_value
, ( bp::arg("mapping_function") )
, "" );
}
{ //::SireMM::LJPerturbation::recreate
typedef ::SireMol::PerturbationPtr ( ::SireMM::LJPerturbation::*recreate_function_type)( ::SireCAS::Expression const &,::SireBase::PropertyMap const & ) const;
recreate_function_type recreate_function_value( &::SireMM::LJPerturbation::recreate );
LJPerturbation_exposer.def(
"recreate"
, recreate_function_value
, ( bp::arg("mapping_function"), bp::arg("map") )
, "" );
}
{ //::SireMM::LJPerturbation::requiredProperties
typedef ::QSet< QString > ( ::SireMM::LJPerturbation::*requiredProperties_function_type)( ) const;
requiredProperties_function_type requiredProperties_function_value( &::SireMM::LJPerturbation::requiredProperties );
LJPerturbation_exposer.def(
"requiredProperties"
, requiredProperties_function_value
, "Return the properties required or changed by this perturbation" );
}
{ //::SireMM::LJPerturbation::sigmaMappingFunction
typedef ::SireCAS::Expression const & ( ::SireMM::LJPerturbation::*sigmaMappingFunction_function_type)( ) const;
sigmaMappingFunction_function_type sigmaMappingFunction_function_value( &::SireMM::LJPerturbation::sigmaMappingFunction );
LJPerturbation_exposer.def(
"sigmaMappingFunction"
, sigmaMappingFunction_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the function used to map sigma\nThrow: SireError::invalid_state\n" );
}
{ //::SireMM::LJPerturbation::substitute
typedef ::SireMol::PerturbationPtr ( ::SireMM::LJPerturbation::*substitute_function_type)( ::SireCAS::Identities const & ) const;
substitute_function_type substitute_function_value( &::SireMM::LJPerturbation::substitute );
LJPerturbation_exposer.def(
"substitute"
, substitute_function_value
, ( bp::arg("identities") )
, "Substitute the identities in identities in all of the mapping functions\nused by this perturbation. This is useful if, for example, you want to\nswitch from using lambda to control the perturbation to using alpha, e.g.\n" );
}
{ //::SireMM::LJPerturbation::toString
typedef ::QString ( ::SireMM::LJPerturbation::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMM::LJPerturbation::toString );
LJPerturbation_exposer.def(
"toString"
, toString_function_value
, "Return a string representation of this perturbation" );
}
{ //::SireMM::LJPerturbation::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMM::LJPerturbation::typeName );
LJPerturbation_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireMM::LJPerturbation::wouldChange
typedef bool ( ::SireMM::LJPerturbation::*wouldChange_function_type)( ::SireMol::Molecule const &,::SireCAS::Values const & ) const;
wouldChange_function_type wouldChange_function_value( &::SireMM::LJPerturbation::wouldChange );
LJPerturbation_exposer.def(
"wouldChange"
, wouldChange_function_value
, ( bp::arg("molecule"), bp::arg("values") )
, "Return whether or not this perturbation with the passed values would\nchange the molecule molecule" );
}
LJPerturbation_exposer.staticmethod( "typeName" );
LJPerturbation_exposer.def( "__copy__", &__copy__);
LJPerturbation_exposer.def( "__deepcopy__", &__copy__);
LJPerturbation_exposer.def( "clone", &__copy__);
LJPerturbation_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::LJPerturbation >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
LJPerturbation_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::LJPerturbation >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
LJPerturbation_exposer.def( "__str__", &__str__< ::SireMM::LJPerturbation > );
LJPerturbation_exposer.def( "__repr__", &__str__< ::SireMM::LJPerturbation > );
}
}
void register_MultiVector_class(){
{ //::SireMaths::MultiVector
typedef bp::class_< SireMaths::MultiVector > MultiVector_exposer_t;
MultiVector_exposer_t MultiVector_exposer = MultiVector_exposer_t( "MultiVector", "\nThis is a vectorised version of Vector, e.g. x, y, and z\nare held as MultiDouble objects, meaning that this is a\npacked vector of vectors\n\nAuthor: Christopher Woods\n", bp::init< >("") );
bp::scope MultiVector_scope( MultiVector_exposer );
MultiVector_exposer.def( bp::init< SireMaths::MultiDouble const & >(( bp::arg("value") ), "Copy constructor") );
MultiVector_exposer.def( bp::init< SireMaths::MultiDouble const &, SireMaths::MultiDouble const &, SireMaths::MultiDouble const & >(( bp::arg("x"), bp::arg("y"), bp::arg("z") ), "") );
MultiVector_exposer.def( bp::init< SireMaths::Vector const *, int >(( bp::arg("array"), bp::arg("size") ), "Construct from an array of Vectors. This array cannot be greater\nthan MultiDouble::size()") );
MultiVector_exposer.def( bp::init< QVector< SireMaths::Vector > const & >(( bp::arg("array") ), "Construct from an array of Vectors. This array cannot be greater\nthan MultiDouble::size()") );
MultiVector_exposer.def( bp::init< SireMaths::MultiVector const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireMaths::MultiVector::angle
typedef ::SireMaths::MultiDouble ( *angle_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & );
angle_function_type angle_function_value( &::SireMaths::MultiVector::angle );
MultiVector_exposer.def(
"angle"
, angle_function_value
, ( bp::arg("v0"), bp::arg("v1") )
, "Return the angle between vectors v0 and v1 - this is the smallest\nangle, and will always lie between 0 and 180 degrees" );
}
{ //::SireMaths::MultiVector::angle
typedef ::SireMaths::MultiDouble ( *angle_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const &,::SireMaths::MultiVector const & );
angle_function_type angle_function_value( &::SireMaths::MultiVector::angle );
MultiVector_exposer.def(
"angle"
, angle_function_value
, ( bp::arg("v0"), bp::arg("v1"), bp::arg("v2") )
, "Return the angle between v0-v1-v2 (treating the vectors as points in space)" );
}
{ //::SireMaths::MultiVector::at
typedef ::SireMaths::Vector ( ::SireMaths::MultiVector::*at_function_type)( int ) const;
at_function_type at_function_value( &::SireMaths::MultiVector::at );
MultiVector_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, "Access the ith vector in the MultiVector" );
}
{ //::SireMaths::MultiVector::b
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*b_function_type)( ) const;
b_function_type b_function_value( &::SireMaths::MultiVector::b );
MultiVector_exposer.def(
"b"
, b_function_value
, "Return the components via rgb (limited between 0 and 1)" );
}
{ //::SireMaths::MultiVector::bearing
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*bearing_function_type)( ) const;
bearing_function_type bearing_function_value( &::SireMaths::MultiVector::bearing );
MultiVector_exposer.def(
"bearing"
, bearing_function_value
, "Return the bearing of this vector against (0,1,0) (north) on the xy plane" );
}
{ //::SireMaths::MultiVector::bearingXY
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*bearingXY_function_type)( ::SireMaths::MultiVector const & ) const;
bearingXY_function_type bearingXY_function_value( &::SireMaths::MultiVector::bearingXY );
MultiVector_exposer.def(
"bearingXY"
, bearingXY_function_value
, ( bp::arg("v") )
, "Return the bearing of this vector against v on the xy plane" );
}
{ //::SireMaths::MultiVector::bearingXZ
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*bearingXZ_function_type)( ::SireMaths::MultiVector const & ) const;
bearingXZ_function_type bearingXZ_function_value( &::SireMaths::MultiVector::bearingXZ );
MultiVector_exposer.def(
"bearingXZ"
, bearingXZ_function_value
, ( bp::arg("v") )
, "Return the bearing of this vector against v on the xz plane" );
}
{ //::SireMaths::MultiVector::bearingYZ
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*bearingYZ_function_type)( ::SireMaths::MultiVector const & ) const;
bearingYZ_function_type bearingYZ_function_value( &::SireMaths::MultiVector::bearingYZ );
MultiVector_exposer.def(
"bearingYZ"
, bearingYZ_function_value
, ( bp::arg("v") )
, "Return the bearing of this vector against v on the yz plane" );
}
{ //::SireMaths::MultiVector::count
typedef int ( *count_function_type )( );
count_function_type count_function_value( &::SireMaths::MultiVector::count );
MultiVector_exposer.def(
"count"
, count_function_value
, "Return the number of vectors in this MultiVector" );
}
{ //::SireMaths::MultiVector::cross
typedef ::SireMaths::MultiVector ( *cross_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & );
cross_function_type cross_function_value( &::SireMaths::MultiVector::cross );
MultiVector_exposer.def(
"cross"
, cross_function_value
, ( bp::arg("v0"), bp::arg("v1") )
, "Return the cross product of v0 and v1" );
}
{ //::SireMaths::MultiVector::dihedral
typedef ::SireMaths::MultiDouble ( *dihedral_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const &,::SireMaths::MultiVector const &,::SireMaths::MultiVector const & );
dihedral_function_type dihedral_function_value( &::SireMaths::MultiVector::dihedral );
MultiVector_exposer.def(
"dihedral"
, dihedral_function_value
, ( bp::arg("v0"), bp::arg("v1"), bp::arg("v2"), bp::arg("v3") )
, "Return the dihedral angle between v0-v1-v2-v3 (treating the vectors as points)" );
}
{ //::SireMaths::MultiVector::direction
typedef ::SireMaths::MultiVector ( ::SireMaths::MultiVector::*direction_function_type)( ) const;
direction_function_type direction_function_value( &::SireMaths::MultiVector::direction );
MultiVector_exposer.def(
"direction"
, direction_function_value
, "Return the unit vector pointing in the direction of this vector" );
}
{ //::SireMaths::MultiVector::distance
typedef ::SireMaths::MultiDouble ( *distance_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & );
distance_function_type distance_function_value( &::SireMaths::MultiVector::distance );
MultiVector_exposer.def(
"distance"
, distance_function_value
, ( bp::arg("v1"), bp::arg("v2") )
, "Return the distance between two vectors" );
}
{ //::SireMaths::MultiVector::distance2
typedef ::SireMaths::MultiDouble ( *distance2_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & );
distance2_function_type distance2_function_value( &::SireMaths::MultiVector::distance2 );
MultiVector_exposer.def(
"distance2"
, distance2_function_value
, ( bp::arg("v1"), bp::arg("v2") )
, "Return the distance squared between two vectors" );
}
{ //::SireMaths::MultiVector::dot
typedef ::SireMaths::MultiDouble ( *dot_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & );
dot_function_type dot_function_value( &::SireMaths::MultiVector::dot );
MultiVector_exposer.def(
"dot"
, dot_function_value
, ( bp::arg("v0"), bp::arg("v1") )
, "Return the dot product of v0 and v1" );
}
{ //::SireMaths::MultiVector::fromArray
typedef ::QVector< SireMaths::MultiVector > ( *fromArray_function_type )( ::SireMaths::Vector const *,int );
fromArray_function_type fromArray_function_value( &::SireMaths::MultiVector::fromArray );
MultiVector_exposer.def(
"fromArray"
, fromArray_function_value
, ( bp::arg("array"), bp::arg("size") )
, "Convert the passed array of vectors into an array of MultiVectors" );
}
{ //::SireMaths::MultiVector::fromArray
typedef ::QVector< SireMaths::MultiVector > ( *fromArray_function_type )( ::QVector< SireMaths::Vector > const & );
fromArray_function_type fromArray_function_value( &::SireMaths::MultiVector::fromArray );
MultiVector_exposer.def(
"fromArray"
, fromArray_function_value
, ( bp::arg("array") )
, "Convert the passed array of vectors into an array of MultiVectors" );
}
{ //::SireMaths::MultiVector::g
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*g_function_type)( ) const;
g_function_type g_function_value( &::SireMaths::MultiVector::g );
MultiVector_exposer.def(
"g"
, g_function_value
, "Return the components via rgb (limited between 0 and 1)" );
}
{ //::SireMaths::MultiVector::generate
typedef ::SireMaths::MultiVector ( *generate_function_type )( ::SireMaths::MultiDouble const &,::SireMaths::MultiVector const &,::SireMaths::MultiDouble const &,::SireMaths::MultiVector const &,::SireMaths::MultiDouble const &,::SireMaths::MultiVector const & );
generate_function_type generate_function_value( &::SireMaths::MultiVector::generate );
MultiVector_exposer.def(
"generate"
, generate_function_value
, ( bp::arg("dst"), bp::arg("v1"), bp::arg("ang"), bp::arg("v2"), bp::arg("dih"), bp::arg("v3") )
, "Generate a vector, v0, that has distance dst v0-v1, angle ang v0-v1-v2,\nand dihedral dih v0-v1-v2-v3" );
}
{ //::SireMaths::MultiVector::getitem
typedef ::SireMaths::Vector ( ::SireMaths::MultiVector::*getitem_function_type)( int ) const;
getitem_function_type getitem_function_value( &::SireMaths::MultiVector::getitem );
MultiVector_exposer.def(
"getitem"
, getitem_function_value
, ( bp::arg("i") )
, "Access the ith vector in the MultiVector" );
}
{ //::SireMaths::MultiVector::invDistance
typedef ::SireMaths::MultiDouble ( *invDistance_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & );
invDistance_function_type invDistance_function_value( &::SireMaths::MultiVector::invDistance );
MultiVector_exposer.def(
"invDistance"
, invDistance_function_value
, ( bp::arg("v1"), bp::arg("v2") )
, "Return the 1 distance between two vectors" );
}
{ //::SireMaths::MultiVector::invDistance2
typedef ::SireMaths::MultiDouble ( *invDistance2_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & );
invDistance2_function_type invDistance2_function_value( &::SireMaths::MultiVector::invDistance2 );
MultiVector_exposer.def(
"invDistance2"
, invDistance2_function_value
, ( bp::arg("v1"), bp::arg("v2") )
, "Return 1 distance2 between two vectors" );
}
{ //::SireMaths::MultiVector::invLength
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*invLength_function_type)( ) const;
invLength_function_type invLength_function_value( &::SireMaths::MultiVector::invLength );
MultiVector_exposer.def(
"invLength"
, invLength_function_value
, "" );
}
{ //::SireMaths::MultiVector::invLength2
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*invLength2_function_type)( ) const;
invLength2_function_type invLength2_function_value( &::SireMaths::MultiVector::invLength2 );
MultiVector_exposer.def(
"invLength2"
, invLength2_function_value
, "Return the inverse length squared" );
}
{ //::SireMaths::MultiVector::length
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*length_function_type)( ) const;
length_function_type length_function_value( &::SireMaths::MultiVector::length );
MultiVector_exposer.def(
"length"
, length_function_value
, "" );
}
{ //::SireMaths::MultiVector::length2
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*length2_function_type)( ) const;
length2_function_type length2_function_value( &::SireMaths::MultiVector::length2 );
MultiVector_exposer.def(
"length2"
, length2_function_value
, "" );
}
{ //::SireMaths::MultiVector::magnitude
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*magnitude_function_type)( ) const;
magnitude_function_type magnitude_function_value( &::SireMaths::MultiVector::magnitude );
MultiVector_exposer.def(
"magnitude"
, magnitude_function_value
, "Return the length of this vector" );
}
{ //::SireMaths::MultiVector::manhattanLength
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*manhattanLength_function_type)( ) const;
manhattanLength_function_type manhattanLength_function_value( &::SireMaths::MultiVector::manhattanLength );
MultiVector_exposer.def(
"manhattanLength"
, manhattanLength_function_value
, "Return the manhattan length of the vector" );
}
{ //::SireMaths::MultiVector::max
typedef ::SireMaths::MultiVector ( ::SireMaths::MultiVector::*max_function_type)( ::SireMaths::MultiVector const & ) const;
max_function_type max_function_value( &::SireMaths::MultiVector::max );
MultiVector_exposer.def(
"max"
, max_function_value
, ( bp::arg("other") )
, "Return a vector that has the maximum xyz components out of this\nand other" );
}
{ //::SireMaths::MultiVector::min
typedef ::SireMaths::MultiVector ( ::SireMaths::MultiVector::*min_function_type)( ::SireMaths::MultiVector const & ) const;
min_function_type min_function_value( &::SireMaths::MultiVector::min );
MultiVector_exposer.def(
"min"
, min_function_value
, ( bp::arg("other") )
, "Return a vector that has the minimum components" );
}
{ //::SireMaths::MultiVector::normalise
typedef ::SireMaths::MultiVector ( ::SireMaths::MultiVector::*normalise_function_type)( ) const;
normalise_function_type normalise_function_value( &::SireMaths::MultiVector::normalise );
MultiVector_exposer.def(
"normalise"
, normalise_function_value
, "Return a normalised form of the vector" );
}
MultiVector_exposer.def( bp::self != bp::self );
MultiVector_exposer.def( -bp::self );
{ //::SireMaths::MultiVector::operator=
typedef ::SireMaths::MultiVector & ( ::SireMaths::MultiVector::*assign_function_type)( ::SireMaths::MultiVector const & ) ;
assign_function_type assign_function_value( &::SireMaths::MultiVector::operator= );
MultiVector_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
MultiVector_exposer.def( bp::self == bp::self );
{ //::SireMaths::MultiVector::operator[]
typedef ::SireMaths::Vector ( ::SireMaths::MultiVector::*__getitem___function_type)( int ) const;
__getitem___function_type __getitem___function_value( &::SireMaths::MultiVector::operator[] );
MultiVector_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, "" );
}
{ //::SireMaths::MultiVector::quickSet
typedef void ( ::SireMaths::MultiVector::*quickSet_function_type)( int,::SireMaths::Vector const & ) ;
quickSet_function_type quickSet_function_value( &::SireMaths::MultiVector::quickSet );
MultiVector_exposer.def(
"quickSet"
, quickSet_function_value
, ( bp::arg("i"), bp::arg("val") )
, "Quickly set the values of the vector, without checking the index is valid" );
}
{ //::SireMaths::MultiVector::r
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*r_function_type)( ) const;
r_function_type r_function_value( &::SireMaths::MultiVector::r );
MultiVector_exposer.def(
"r"
, r_function_value
, "Return the components via rgb (limited between 0 and 1)" );
}
{ //::SireMaths::MultiVector::set
typedef void ( ::SireMaths::MultiVector::*set_function_type)( ::SireMaths::MultiDouble const &,::SireMaths::MultiDouble const &,::SireMaths::MultiDouble const & ) ;
set_function_type set_function_value( &::SireMaths::MultiVector::set );
MultiVector_exposer.def(
"set"
, set_function_value
, ( bp::arg("x"), bp::arg("y"), bp::arg("z") )
, "Set individual values of the vector" );
}
{ //::SireMaths::MultiVector::set
typedef void ( ::SireMaths::MultiVector::*set_function_type)( int,::SireMaths::Vector const & ) ;
set_function_type set_function_value( &::SireMaths::MultiVector::set );
MultiVector_exposer.def(
"set"
, set_function_value
, ( bp::arg("i"), bp::arg("val") )
, "Set individual values of the vector" );
}
{ //::SireMaths::MultiVector::setB
typedef void ( ::SireMaths::MultiVector::*setB_function_type)( ::SireMaths::MultiDouble const & ) ;
setB_function_type setB_function_value( &::SireMaths::MultiVector::setB );
MultiVector_exposer.def(
"setB"
, setB_function_value
, ( bp::arg("val") )
, "Set individual values of the vector" );
}
{ //::SireMaths::MultiVector::setG
typedef void ( ::SireMaths::MultiVector::*setG_function_type)( ::SireMaths::MultiDouble const & ) ;
setG_function_type setG_function_value( &::SireMaths::MultiVector::setG );
MultiVector_exposer.def(
"setG"
, setG_function_value
, ( bp::arg("val") )
, "Set individual values of the vector" );
}
{ //::SireMaths::MultiVector::setMax
typedef void ( ::SireMaths::MultiVector::*setMax_function_type)( ::SireMaths::MultiVector const & ) ;
setMax_function_type setMax_function_value( &::SireMaths::MultiVector::setMax );
MultiVector_exposer.def(
"setMax"
, setMax_function_value
, ( bp::arg("other") )
, "Set this Vector so that it has the maximum xyz components out of\nthis and other (e.g. this->x = max(this->x(),other.x() etc.)" );
}
{ //::SireMaths::MultiVector::setMin
typedef void ( ::SireMaths::MultiVector::*setMin_function_type)( ::SireMaths::MultiVector const & ) ;
setMin_function_type setMin_function_value( &::SireMaths::MultiVector::setMin );
MultiVector_exposer.def(
"setMin"
, setMin_function_value
, ( bp::arg("other") )
, "Set this Vector so that it has the minimum xyz components" );
}
{ //::SireMaths::MultiVector::setR
typedef void ( ::SireMaths::MultiVector::*setR_function_type)( ::SireMaths::MultiDouble const & ) ;
setR_function_type setR_function_value( &::SireMaths::MultiVector::setR );
MultiVector_exposer.def(
"setR"
, setR_function_value
, ( bp::arg("val") )
, "Set individual values of the vector" );
}
{ //::SireMaths::MultiVector::setX
typedef void ( ::SireMaths::MultiVector::*setX_function_type)( ::SireMaths::MultiDouble const & ) ;
setX_function_type setX_function_value( &::SireMaths::MultiVector::setX );
MultiVector_exposer.def(
"setX"
, setX_function_value
, ( bp::arg("val") )
, "Set individual values of the vector" );
}
{ //::SireMaths::MultiVector::setY
typedef void ( ::SireMaths::MultiVector::*setY_function_type)( ::SireMaths::MultiDouble const & ) ;
setY_function_type setY_function_value( &::SireMaths::MultiVector::setY );
MultiVector_exposer.def(
"setY"
, setY_function_value
, ( bp::arg("val") )
, "Set individual values of the vector" );
}
{ //::SireMaths::MultiVector::setZ
typedef void ( ::SireMaths::MultiVector::*setZ_function_type)( ::SireMaths::MultiDouble const & ) ;
setZ_function_type setZ_function_value( &::SireMaths::MultiVector::setZ );
MultiVector_exposer.def(
"setZ"
, setZ_function_value
, ( bp::arg("val") )
, "Set individual values of the vector" );
}
{ //::SireMaths::MultiVector::size
typedef int ( *size_function_type )( );
size_function_type size_function_value( &::SireMaths::MultiVector::size );
MultiVector_exposer.def(
"size"
, size_function_value
, "Return the number of vectors in this MultiVector" );
}
{ //::SireMaths::MultiVector::swap
typedef void ( *swap_function_type )( ::SireMaths::MultiVector &,int,::SireMaths::MultiVector &,int );
swap_function_type swap_function_value( &::SireMaths::MultiVector::swap );
MultiVector_exposer.def(
"swap"
, swap_function_value
, ( bp::arg("v0"), bp::arg("idx0"), bp::arg("v1"), bp::arg("idx1") )
, "Swap the values of the value at index idx0 in f0 with the value at index idx in f1" );
}
{ //::SireMaths::MultiVector::toString
typedef ::QString ( ::SireMaths::MultiVector::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMaths::MultiVector::toString );
MultiVector_exposer.def(
"toString"
, toString_function_value
, "Return a QString representation of the vector" );
}
{ //::SireMaths::MultiVector::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMaths::MultiVector::typeName );
MultiVector_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireMaths::MultiVector::what
typedef char const * ( ::SireMaths::MultiVector::*what_function_type)( ) const;
what_function_type what_function_value( &::SireMaths::MultiVector::what );
MultiVector_exposer.def(
"what"
, what_function_value
, "" );
}
{ //::SireMaths::MultiVector::x
typedef ::SireMaths::MultiDouble const & ( ::SireMaths::MultiVector::*x_function_type)( ) const;
x_function_type x_function_value( &::SireMaths::MultiVector::x );
MultiVector_exposer.def(
"x"
, x_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMaths::MultiVector::y
typedef ::SireMaths::MultiDouble const & ( ::SireMaths::MultiVector::*y_function_type)( ) const;
y_function_type y_function_value( &::SireMaths::MultiVector::y );
MultiVector_exposer.def(
"y"
, y_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMaths::MultiVector::z
typedef ::SireMaths::MultiDouble const & ( ::SireMaths::MultiVector::*z_function_type)( ) const;
z_function_type z_function_value( &::SireMaths::MultiVector::z );
MultiVector_exposer.def(
"z"
, z_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
MultiVector_exposer.staticmethod( "angle" );
MultiVector_exposer.staticmethod( "count" );
MultiVector_exposer.staticmethod( "cross" );
MultiVector_exposer.staticmethod( "dihedral" );
MultiVector_exposer.staticmethod( "distance" );
MultiVector_exposer.staticmethod( "distance2" );
MultiVector_exposer.staticmethod( "dot" );
MultiVector_exposer.staticmethod( "fromArray" );
MultiVector_exposer.staticmethod( "generate" );
MultiVector_exposer.staticmethod( "invDistance" );
MultiVector_exposer.staticmethod( "invDistance2" );
MultiVector_exposer.staticmethod( "size" );
MultiVector_exposer.staticmethod( "swap" );
MultiVector_exposer.staticmethod( "typeName" );
MultiVector_exposer.def( bp::self * bp::other< SireMaths::MultiDouble >() );
MultiVector_exposer.def( bp::self * bp::other< SireMaths::MultiQuaternion >() );
MultiVector_exposer.def( bp::self + bp::self );
MultiVector_exposer.def( bp::self - bp::self );
MultiVector_exposer.def( bp::self / bp::other< SireMaths::MultiDouble >() );
MultiVector_exposer.def( "__copy__", &__copy__);
MultiVector_exposer.def( "__deepcopy__", &__copy__);
MultiVector_exposer.def( "clone", &__copy__);
MultiVector_exposer.def( "__str__", &__str__< ::SireMaths::MultiVector > );
MultiVector_exposer.def( "__repr__", &__str__< ::SireMaths::MultiVector > );
MultiVector_exposer.def( "__len__", &__len_size< ::SireMaths::MultiVector > );
MultiVector_exposer.def( "__getitem__", &::SireMaths::MultiVector::getitem );
}
}
void register_BoxPatching_class(){
{ //::SireVol::BoxPatching
typedef bp::class_< SireVol::BoxPatching, bp::bases< SireVol::Patching, SireBase::Property > > BoxPatching_exposer_t;
BoxPatching_exposer_t BoxPatching_exposer = BoxPatching_exposer_t( "BoxPatching", bp::init< >() );
bp::scope BoxPatching_scope( BoxPatching_exposer );
BoxPatching_exposer.def( bp::init< SireVol::Space const & >(( bp::arg("space") )) );
BoxPatching_exposer.def( bp::init< SireVol::Space const &, SireMaths::Vector const & >(( bp::arg("space"), bp::arg("center") )) );
BoxPatching_exposer.def( bp::init< SireVol::Space const &, SireUnits::Dimension::Length >(( bp::arg("space"), bp::arg("patch_size") )) );
BoxPatching_exposer.def( bp::init< SireVol::Space const &, SireUnits::Dimension::Length, SireMaths::Vector const & >(( bp::arg("space"), bp::arg("patch_size"), bp::arg("center") )) );
BoxPatching_exposer.def( bp::init< SireVol::BoxPatching const & >(( bp::arg("other") )) );
{ //::SireVol::BoxPatching::center
typedef ::SireMaths::Vector ( ::SireVol::BoxPatching::*center_function_type )( ) const;
center_function_type center_function_value( &::SireVol::BoxPatching::center );
BoxPatching_exposer.def(
"center"
, center_function_value );
}
{ //::SireVol::BoxPatching::nPatches
typedef int ( ::SireVol::BoxPatching::*nPatches_function_type )( ) const;
nPatches_function_type nPatches_function_value( &::SireVol::BoxPatching::nPatches );
BoxPatching_exposer.def(
"nPatches"
, nPatches_function_value );
}
BoxPatching_exposer.def( bp::self != bp::self );
{ //::SireVol::BoxPatching::operator=
typedef ::SireVol::BoxPatching & ( ::SireVol::BoxPatching::*assign_function_type )( ::SireVol::BoxPatching const & ) ;
assign_function_type assign_function_value( &::SireVol::BoxPatching::operator= );
BoxPatching_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
BoxPatching_exposer.def( bp::self == bp::self );
{ //::SireVol::BoxPatching::patchBox
typedef ::SireVol::AABox ( ::SireVol::BoxPatching::*patchBox_function_type )( int ) const;
patchBox_function_type patchBox_function_value( &::SireVol::BoxPatching::patchBox );
BoxPatching_exposer.def(
"patchBox"
, patchBox_function_value
, ( bp::arg("i") ) );
}
{ //::SireVol::BoxPatching::patchBox
typedef ::SireVol::AABox ( ::SireVol::BoxPatching::*patchBox_function_type )( ::SireMaths::Vector const & ) const;
patchBox_function_type patchBox_function_value( &::SireVol::BoxPatching::patchBox );
BoxPatching_exposer.def(
"patchBox"
, patchBox_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::BoxPatching::patchDimension
typedef ::SireMaths::Vector ( ::SireVol::BoxPatching::*patchDimension_function_type )( ) const;
patchDimension_function_type patchDimension_function_value( &::SireVol::BoxPatching::patchDimension );
BoxPatching_exposer.def(
"patchDimension"
, patchDimension_function_value );
}
{ //::SireVol::BoxPatching::patchIndex
typedef int ( ::SireVol::BoxPatching::*patchIndex_function_type )( ::SireMaths::Vector const & ) const;
patchIndex_function_type patchIndex_function_value( &::SireVol::BoxPatching::patchIndex );
BoxPatching_exposer.def(
"patchIndex"
, patchIndex_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::BoxPatching::patchIndexAndCenter
typedef ::QPair< int, SireMaths::Vector > ( ::SireVol::BoxPatching::*patchIndexAndCenter_function_type )( ::SireMaths::Vector const & ) const;
patchIndexAndCenter_function_type patchIndexAndCenter_function_value( &::SireVol::BoxPatching::patchIndexAndCenter );
BoxPatching_exposer.def(
"patchIndexAndCenter"
, patchIndexAndCenter_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::BoxPatching::patchSize
typedef ::SireUnits::Dimension::Length ( ::SireVol::BoxPatching::*patchSize_function_type )( ) const;
patchSize_function_type patchSize_function_value( &::SireVol::BoxPatching::patchSize );
BoxPatching_exposer.def(
"patchSize"
, patchSize_function_value );
}
{ //::SireVol::BoxPatching::repatch
typedef ::SireVol::PatchingPtr ( ::SireVol::BoxPatching::*repatch_function_type )( ::SireVol::Space const & ) const;
repatch_function_type repatch_function_value( &::SireVol::BoxPatching::repatch );
BoxPatching_exposer.def(
"repatch"
, repatch_function_value
, ( bp::arg("new_space") ) );
}
{ //::SireVol::BoxPatching::toString
typedef ::QString ( ::SireVol::BoxPatching::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireVol::BoxPatching::toString );
BoxPatching_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireVol::BoxPatching::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireVol::BoxPatching::typeName );
BoxPatching_exposer.def(
"typeName"
, typeName_function_value );
}
BoxPatching_exposer.staticmethod( "typeName" );
BoxPatching_exposer.def( "__copy__", &__copy__);
BoxPatching_exposer.def( "__deepcopy__", &__copy__);
BoxPatching_exposer.def( "clone", &__copy__);
BoxPatching_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::BoxPatching >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
BoxPatching_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::BoxPatching >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
BoxPatching_exposer.def( "__str__", &__str__< ::SireVol::BoxPatching > );
BoxPatching_exposer.def( "__repr__", &__str__< ::SireVol::BoxPatching > );
}
}
