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_ExBase_class(){
{ //::SireCAS::ExBase
typedef bp::class_< SireCAS::ExBase, boost::noncopyable > ExBase_exposer_t;
ExBase_exposer_t ExBase_exposer = ExBase_exposer_t( "ExBase", "\nPure-virtual base class of all of the parts of mathematical expressions.\n\nThis class provides the atom of SireCAS. ExBase objects are combined together\nto form complete expressions. All constants, functions and symbols are derived\nfrom this object.\n\nThis class is an example of an implicitly shared, self-managed object, and\nis designed so that it can be held by SharedPolyPointer (indeed,\nExpressionBase is just a proxy for SharedPolyPointer<ExBase>).\n\nAuthor: Christopher Woods\n", bp::no_init );
bp::scope ExBase_scope( ExBase_exposer );
{ //::SireCAS::ExBase::children
typedef ::SireCAS::Expressions ( ::SireCAS::ExBase::*children_function_type)( ) const;
children_function_type children_function_value( &::SireCAS::ExBase::children );
ExBase_exposer.def(
"children"
, children_function_value
, "Return the child expressions of this Expression" );
}
{ //::SireCAS::ExBase::conjugate
typedef ::SireCAS::Expression ( ::SireCAS::ExBase::*conjugate_function_type)( ) const;
conjugate_function_type conjugate_function_value( &::SireCAS::ExBase::conjugate );
ExBase_exposer.def(
"conjugate"
, conjugate_function_value
, "Return the complex conjugate of this expression" );
}
{ //::SireCAS::ExBase::differentiate
typedef ::SireCAS::Expression ( ::SireCAS::ExBase::*differentiate_function_type)( ::SireCAS::Symbol const & ) const;
differentiate_function_type differentiate_function_value( &::SireCAS::ExBase::differentiate );
ExBase_exposer.def(
"differentiate"
, differentiate_function_value
, ( bp::arg("symbol") )
, "Return an expression that the differential of this ExBase\nwith respect to symbol. Note an exception may\nbe thrown if this ExBase cannot be differentiated.\nThrow: SireCAS::unavailable_differential\n" );
}
{ //::SireCAS::ExBase::evaluate
typedef double ( ::SireCAS::ExBase::*evaluate_function_type)( ::SireCAS::Values const & ) const;
evaluate_function_type evaluate_function_value( &::SireCAS::ExBase::evaluate );
ExBase_exposer.def(
"evaluate"
, evaluate_function_value
, ( bp::arg("values") )
, "Evaluate this ExBase using values values. Any\nmissing symbols are assumed to equal zero.\n\nNote that an exception will be thrown if the result of the\nevaluation of this, or one of its children, is complex.\n\nThrow: SireMaths::domain_error\n" );
}
{ //::SireCAS::ExBase::evaluate
typedef ::SireMaths::Complex ( ::SireCAS::ExBase::*evaluate_function_type)( ::SireCAS::ComplexValues const & ) const;
evaluate_function_type evaluate_function_value( &::SireCAS::ExBase::evaluate );
ExBase_exposer.def(
"evaluate"
, evaluate_function_value
, ( bp::arg("values") )
, "Evaluate this ExBase using the complex values values.\nAny missing symbols are assumed to equal zero." );
}
{ //::SireCAS::ExBase::expand
typedef ::QList< SireCAS::Factor > ( ::SireCAS::ExBase::*expand_function_type)( ::SireCAS::Symbol const & ) const;
expand_function_type expand_function_value( &::SireCAS::ExBase::expand );
ExBase_exposer.def(
"expand"
, expand_function_value
, ( bp::arg("symbol") )
, "Rearrange this expression into the form\nm x^i + n x^j + ... + constant\nand return the factors and powers of x\n\nThrow: SireCAS::rearrangement_error\n" );
}
{ //::SireCAS::ExBase::functions
typedef ::SireCAS::Functions ( ::SireCAS::ExBase::*functions_function_type)( ) const;
functions_function_type functions_function_value( &::SireCAS::ExBase::functions );
ExBase_exposer.def(
"functions"
, functions_function_value
, "Return the set of Functions that appear in this ExBase" );
}
{ //::SireCAS::ExBase::hash
typedef ::uint ( ::SireCAS::ExBase::*hash_function_type)( ) const;
hash_function_type hash_function_value( &::SireCAS::ExBase::hash );
ExBase_exposer.def(
"hash"
, hash_function_value
, "Return a hash of this object - return a combination of the\nidentifying magic for the class and a hash for its contents." );
}
{ //::SireCAS::ExBase::integrate
typedef ::SireCAS::Expression ( ::SireCAS::ExBase::*integrate_function_type)( ::SireCAS::Symbol const & ) const;
integrate_function_type integrate_function_value( &::SireCAS::ExBase::integrate );
ExBase_exposer.def(
"integrate"
, integrate_function_value
, ( bp::arg("symbol") )
, "Return the indefinite integral of this ExBase with respect to\nsymbol. This is not guaranteed to work() and will return an\nexpression of the form Sum( integral(exbase) + integral_constant ).\nIf it doesnt work then an exception will be throw.\nThrow: SireCAS::unavailable_integral\n" );
}
{ //::SireCAS::ExBase::isComplex
typedef bool ( ::SireCAS::ExBase::*isComplex_function_type)( ) const;
isComplex_function_type isComplex_function_value( &::SireCAS::ExBase::isComplex );
ExBase_exposer.def(
"isComplex"
, isComplex_function_value
, "Return whether or not this expression contains any complex (imaginary)\nparts" );
}
{ //::SireCAS::ExBase::isCompound
typedef bool ( ::SireCAS::ExBase::*isCompound_function_type)( ) const;
isCompound_function_type isCompound_function_value( &::SireCAS::ExBase::isCompound );
ExBase_exposer.def(
"isCompound"
, isCompound_function_value
, "Return whether or not this is a compound expression, and thus as such\nrequires brackets placed around it when it is printed. Examples include\nSum, Product and Power. For most other functions it is safe to leave\nthis as false." );
}
{ //::SireCAS::ExBase::isConstant
typedef bool ( ::SireCAS::ExBase::*isConstant_function_type)( ) const;
isConstant_function_type isConstant_function_value( &::SireCAS::ExBase::isConstant );
ExBase_exposer.def(
"isConstant"
, isConstant_function_value
, "Return whether or not this is a constant expression (does not\ndepend on any symbols)" );
}
{ //::SireCAS::ExBase::isFunction
typedef bool ( ::SireCAS::ExBase::*isFunction_function_type)( ::SireCAS::Symbol const & ) const;
isFunction_function_type isFunction_function_value( &::SireCAS::ExBase::isFunction );
ExBase_exposer.def(
"isFunction"
, isFunction_function_value
, ( bp::arg("arg0") )
, "Return whether or not this is a function of the passed Symbol" );
}
ExBase_exposer.def( bp::self != bp::self );
ExBase_exposer.def( -bp::self );
{ //::SireCAS::ExBase::operator=
typedef ::SireCAS::ExBase & ( ::SireCAS::ExBase::*assign_function_type)( ::SireCAS::ExBase const & ) ;
assign_function_type assign_function_value( &::SireCAS::ExBase::operator= );
ExBase_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("arg0") )
, bp::return_self< >()
, "Assignment operator" );
}
ExBase_exposer.def( bp::self == bp::self );
{ //::SireCAS::ExBase::series
typedef ::SireCAS::Expression ( ::SireCAS::ExBase::*series_function_type)( ::SireCAS::Symbol const &,int ) const;
series_function_type series_function_value( &::SireCAS::ExBase::series );
ExBase_exposer.def(
"series"
, series_function_value
, ( bp::arg("symbol"), bp::arg("n") )
, "Return a series expansion of this expression with respect to\nsymbol, if possible, to order\nn. This is not guaranteed to work, and will return this expression\nunchanged if it doesnt work. If it is expanded, then a series\nwill be returned, together with an estimate of the error (e.g. O(x^2))" );
}
{ //::SireCAS::ExBase::simplify
typedef ::SireCAS::Expression ( ::SireCAS::ExBase::*simplify_function_type)( int ) const;
simplify_function_type simplify_function_value( &::SireCAS::ExBase::simplify );
ExBase_exposer.def(
"simplify"
, simplify_function_value
, ( bp::arg("options")=(int)(0) )
, "Try to simplify this expression. This will try to use known mathematical\nidentities to convert complex expressions down to more simple ones.\nIf SireCAS::UNSAFE_COMPLEX_SIMPLIFICATIONS is true, then identities\nthat are not safe for complex math are used, e.g. z = sin(arcsin(z))." );
}
{ //::SireCAS::ExBase::substitute
typedef ::SireCAS::Expression ( ::SireCAS::ExBase::*substitute_function_type)( ::SireCAS::Identities const & ) const;
substitute_function_type substitute_function_value( &::SireCAS::ExBase::substitute );
ExBase_exposer.def(
"substitute"
, substitute_function_value
, ( bp::arg("identities") )
, "Return an expression that has the identities in identities\nsubstituted into this expression" );
}
{ //::SireCAS::ExBase::symbols
typedef ::SireCAS::Symbols ( ::SireCAS::ExBase::*symbols_function_type)( ) const;
symbols_function_type symbols_function_value( &::SireCAS::ExBase::symbols );
ExBase_exposer.def(
"symbols"
, symbols_function_value
, "Return the set of Symbols that appear in this ExBase" );
}
{ //::SireCAS::ExBase::toOpenMMString
typedef ::QString ( ::SireCAS::ExBase::*toOpenMMString_function_type)( ) const;
toOpenMMString_function_type toOpenMMString_function_value( &::SireCAS::ExBase::toOpenMMString );
ExBase_exposer.def(
"toOpenMMString"
, toOpenMMString_function_value
, "Return a string representation of this object in the OpenMM syntax" );
}
{ //::SireCAS::ExBase::toString
typedef ::QString ( ::SireCAS::ExBase::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireCAS::ExBase::toString );
ExBase_exposer.def(
"toString"
, toString_function_value
, "Return a string representation of this object" );
}
{ //::SireCAS::ExBase::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireCAS::ExBase::typeName );
ExBase_exposer.def(
"typeName"
, typeName_function_value
, "Return the name of this class type" );
}
{ //::SireCAS::ExBase::what
typedef char const * ( ::SireCAS::ExBase::*what_function_type)( ) const;
what_function_type what_function_value( &::SireCAS::ExBase::what );
ExBase_exposer.def(
"what"
, what_function_value
, "Return the name of the type of this ExBase object" );
}
ExBase_exposer.staticmethod( "typeName" );
ExBase_exposer.def( bp::self * bp::self );
ExBase_exposer.def( bp::self * bp::other< SireCAS::Expression >() );
ExBase_exposer.def( bp::self * bp::other< double >() );
ExBase_exposer.def( bp::other< double >() * bp::self );
ExBase_exposer.def( bp::self * bp::other< SireMaths::Complex >() );
ExBase_exposer.def( bp::self + bp::self );
ExBase_exposer.def( bp::self + bp::other< SireCAS::Expression >() );
ExBase_exposer.def( bp::self + bp::other< double >() );
ExBase_exposer.def( bp::other< double >() + bp::self );
ExBase_exposer.def( bp::self + bp::other< SireMaths::Complex >() );
ExBase_exposer.def( bp::self - bp::self );
ExBase_exposer.def( bp::self - bp::other< SireCAS::Expression >() );
ExBase_exposer.def( bp::self - bp::other< double >() );
ExBase_exposer.def( bp::other< double >() - bp::self );
ExBase_exposer.def( bp::self - bp::other< SireMaths::Complex >() );
ExBase_exposer.def( bp::self / bp::self );
ExBase_exposer.def( bp::self / bp::other< SireCAS::Expression >() );
ExBase_exposer.def( bp::self / bp::other< double >() );
ExBase_exposer.def( bp::other< double >() / bp::self );
ExBase_exposer.def( bp::self / bp::other< SireMaths::Complex >() );
ExBase_exposer.def( self + self );
ExBase_exposer.def( self - self );
ExBase_exposer.def( self * self );
ExBase_exposer.def( self / self );
ExBase_exposer.def( other<double>() + self );
ExBase_exposer.def( other<double>() - self );
ExBase_exposer.def( other<double>() * self );
ExBase_exposer.def( other<double>() / self );
ExBase_exposer.def( self + other<double>() );
ExBase_exposer.def( self - other<double>() );
ExBase_exposer.def( self * other<double>() );
ExBase_exposer.def( self / other<double>() );
ExBase_exposer.def( other<SireMaths::Complex>() + self );
ExBase_exposer.def( other<SireMaths::Complex>() - self );
ExBase_exposer.def( other<SireMaths::Complex>() * self );
ExBase_exposer.def( other<SireMaths::Complex>() / self );
ExBase_exposer.def( self + other<SireMaths::Complex>() );
ExBase_exposer.def( self - other<SireMaths::Complex>() );
ExBase_exposer.def( self * other<SireMaths::Complex>() );
ExBase_exposer.def( self / other<SireMaths::Complex>() );
ExBase_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::ExBase >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ExBase_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::ExBase >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ExBase_exposer.def( "__str__", &__str__< ::SireCAS::ExBase > );
ExBase_exposer.def( "__repr__", &__str__< ::SireCAS::ExBase > );
ExBase_exposer.def( "__hash__", &::SireCAS::ExBase::hash );
}
}
void register_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_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_OpenMMMDIntegrator_class(){
{ //::SireMove::OpenMMMDIntegrator
typedef bp::class_< SireMove::OpenMMMDIntegrator, bp::bases< SireMove::Integrator, SireBase::Property > > OpenMMMDIntegrator_exposer_t;
OpenMMMDIntegrator_exposer_t OpenMMMDIntegrator_exposer = OpenMMMDIntegrator_exposer_t( "OpenMMMDIntegrator", bp::init< bp::optional< bool > >(( bp::arg("frequent_save_velocities")=(bool)(false) )) );
bp::scope OpenMMMDIntegrator_scope( OpenMMMDIntegrator_exposer );
OpenMMMDIntegrator_exposer.def( bp::init< SireMol::MoleculeGroup const &, bp::optional< bool > >(( bp::arg("molecule_group"), bp::arg("frequent_save_velocities")=(bool)(false) )) );
OpenMMMDIntegrator_exposer.def( bp::init< SireMove::OpenMMMDIntegrator const & >(( bp::arg("other") )) );
{ //::SireMove::OpenMMMDIntegrator::createWorkspace
typedef ::SireMove::IntegratorWorkspacePtr ( ::SireMove::OpenMMMDIntegrator::*createWorkspace_function_type )( ::SireBase::PropertyMap const & ) const;
createWorkspace_function_type createWorkspace_function_value( &::SireMove::OpenMMMDIntegrator::createWorkspace );
OpenMMMDIntegrator_exposer.def(
"createWorkspace"
, createWorkspace_function_value
, ( bp::arg("map")=SireBase::PropertyMap() ) );
}
{ //::SireMove::OpenMMMDIntegrator::createWorkspace
typedef ::SireMove::IntegratorWorkspacePtr ( ::SireMove::OpenMMMDIntegrator::*createWorkspace_function_type )( ::SireMol::MoleculeGroup const &,::SireBase::PropertyMap const & ) const;
createWorkspace_function_type createWorkspace_function_value( &::SireMove::OpenMMMDIntegrator::createWorkspace );
OpenMMMDIntegrator_exposer.def(
"createWorkspace"
, createWorkspace_function_value
, ( bp::arg("molgroup"), bp::arg("map")=SireBase::PropertyMap() ) );
}
{ //::SireMove::OpenMMMDIntegrator::ensemble
typedef ::SireMove::Ensemble ( ::SireMove::OpenMMMDIntegrator::*ensemble_function_type )( ) const;
ensemble_function_type ensemble_function_value( &::SireMove::OpenMMMDIntegrator::ensemble );
OpenMMMDIntegrator_exposer.def(
"ensemble"
, ensemble_function_value );
}
{ //::SireMove::OpenMMMDIntegrator::getAndersen
typedef bool ( ::SireMove::OpenMMMDIntegrator::*getAndersen_function_type )( ) ;
getAndersen_function_type getAndersen_function_value( &::SireMove::OpenMMMDIntegrator::getAndersen );
OpenMMMDIntegrator_exposer.def(
"getAndersen"
, getAndersen_function_value );
}
{ //::SireMove::OpenMMMDIntegrator::getAndersen_frequency
typedef double ( ::SireMove::OpenMMMDIntegrator::*getAndersen_frequency_function_type )( ) ;
getAndersen_frequency_function_type getAndersen_frequency_function_value( &::SireMove::OpenMMMDIntegrator::getAndersen_frequency );
OpenMMMDIntegrator_exposer.def(
"getAndersen_frequency"
, getAndersen_frequency_function_value );
}
{ //::SireMove::OpenMMMDIntegrator::getBufferFrequency
typedef int ( ::SireMove::OpenMMMDIntegrator::*getBufferFrequency_function_type )( ) ;
getBufferFrequency_function_type getBufferFrequency_function_value( &::SireMove::OpenMMMDIntegrator::getBufferFrequency );
OpenMMMDIntegrator_exposer.def(
"getBufferFrequency"
, getBufferFrequency_function_value );
}
{ //::SireMove::OpenMMMDIntegrator::getCMMremoval_frequency
typedef int ( ::SireMove::OpenMMMDIntegrator::*getCMMremoval_frequency_function_type )( ) ;
getCMMremoval_frequency_function_type getCMMremoval_frequency_function_value( &::SireMove::OpenMMMDIntegrator::getCMMremoval_frequency );
OpenMMMDIntegrator_exposer.def(
"getCMMremoval_frequency"
, getCMMremoval_frequency_function_value );
}
{ //::SireMove::OpenMMMDIntegrator::getConstraintType
typedef ::QString ( ::SireMove::OpenMMMDIntegrator::*getConstraintType_function_type )( ) ;
getConstraintType_function_type getConstraintType_function_value( &::SireMove::OpenMMMDIntegrator::getConstraintType );
OpenMMMDIntegrator_exposer.def(
"getConstraintType"
, getConstraintType_function_value );
}
{ //::SireMove::OpenMMMDIntegrator::getCutoffType
typedef ::QString ( ::SireMove::OpenMMMDIntegrator::*getCutoffType_function_type )( ) ;
getCutoffType_function_type getCutoffType_function_value( &::SireMove::OpenMMMDIntegrator::getCutoffType );
OpenMMMDIntegrator_exposer.def(
"getCutoffType"
, getCutoffType_function_value );
}
{ //::SireMove::OpenMMMDIntegrator::getCutoff_distance
typedef ::SireUnits::Dimension::Length ( ::SireMove::OpenMMMDIntegrator::*getCutoff_distance_function_type )( ) ;
getCutoff_distance_function_type getCutoff_distance_function_value( &::SireMove::OpenMMMDIntegrator::getCutoff_distance );
OpenMMMDIntegrator_exposer.def(
"getCutoff_distance"
, getCutoff_distance_function_value );
}
{ //::SireMove::OpenMMMDIntegrator::getDeviceIndex
typedef ::QString ( ::SireMove::OpenMMMDIntegrator::*getDeviceIndex_function_type )( ) ;
getDeviceIndex_function_type getDeviceIndex_function_value( &::SireMove::OpenMMMDIntegrator::getDeviceIndex );
OpenMMMDIntegrator_exposer.def(
"getDeviceIndex"
, getDeviceIndex_function_value );
}
{ //::SireMove::OpenMMMDIntegrator::getEquilib_iterations
typedef int ( ::SireMove::OpenMMMDIntegrator::*getEquilib_iterations_function_type )( ) ;
getEquilib_iterations_function_type getEquilib_iterations_function_value( &::SireMove::OpenMMMDIntegrator::getEquilib_iterations );
OpenMMMDIntegrator_exposer.def(
"getEquilib_iterations"
, getEquilib_iterations_function_value );
}
{ //::SireMove::OpenMMMDIntegrator::getEquilib_time_step
typedef ::SireUnits::Dimension::Time ( ::SireMove::OpenMMMDIntegrator::*getEquilib_time_step_function_type )( ) ;
getEquilib_time_step_function_type getEquilib_time_step_function_value( &::SireMove::OpenMMMDIntegrator::getEquilib_time_step );
OpenMMMDIntegrator_exposer.def(
"getEquilib_time_step"
, getEquilib_time_step_function_value );
}
{ //::SireMove::OpenMMMDIntegrator::getField_dielectric
typedef double ( ::SireMove::OpenMMMDIntegrator::*getField_dielectric_function_type )( ) ;
getField_dielectric_function_type getField_dielectric_function_value( &::SireMove::OpenMMMDIntegrator::getField_dielectric );
OpenMMMDIntegrator_exposer.def(
"getField_dielectric"
, getField_dielectric_function_value );
}
{ //::SireMove::OpenMMMDIntegrator::getFriction
typedef ::SireUnits::Dimension::Time ( ::SireMove::OpenMMMDIntegrator::*getFriction_function_type )( ) ;
getFriction_function_type getFriction_function_value( &::SireMove::OpenMMMDIntegrator::getFriction );
OpenMMMDIntegrator_exposer.def(
"getFriction"
, getFriction_function_value );
}
{ //::SireMove::OpenMMMDIntegrator::getIntegration_tollerance
typedef double ( ::SireMove::OpenMMMDIntegrator::*getIntegration_tollerance_function_type )( ) ;
getIntegration_tollerance_function_type getIntegration_tollerance_function_value( &::SireMove::OpenMMMDIntegrator::getIntegration_tollerance );
OpenMMMDIntegrator_exposer.def(
"getIntegration_tollerance"
, getIntegration_tollerance_function_value );
}
{ //::SireMove::OpenMMMDIntegrator::getIntegrator
typedef ::QString ( ::SireMove::OpenMMMDIntegrator::*getIntegrator_function_type )( ) ;
getIntegrator_function_type getIntegrator_function_value( &::SireMove::OpenMMMDIntegrator::getIntegrator );
OpenMMMDIntegrator_exposer.def(
"getIntegrator"
, getIntegrator_function_value );
}
{ //::SireMove::OpenMMMDIntegrator::getLJDispersion
typedef bool ( ::SireMove::OpenMMMDIntegrator::*getLJDispersion_function_type )( ) ;
getLJDispersion_function_type getLJDispersion_function_value( &::SireMove::OpenMMMDIntegrator::getLJDispersion );
OpenMMMDIntegrator_exposer.def(
"getLJDispersion"
, getLJDispersion_function_value );
}
{ //::SireMove::OpenMMMDIntegrator::getMCBarostat
typedef bool ( ::SireMove::OpenMMMDIntegrator::*getMCBarostat_function_type )( ) ;
getMCBarostat_function_type getMCBarostat_function_value( &::SireMove::OpenMMMDIntegrator::getMCBarostat );
OpenMMMDIntegrator_exposer.def(
"getMCBarostat"
, getMCBarostat_function_value );
}
{ //::SireMove::OpenMMMDIntegrator::getMCBarostat_frequency
typedef int ( ::SireMove::OpenMMMDIntegrator::*getMCBarostat_frequency_function_type )( ) ;
getMCBarostat_frequency_function_type getMCBarostat_frequency_function_value( &::SireMove::OpenMMMDIntegrator::getMCBarostat_frequency );
OpenMMMDIntegrator_exposer.def(
"getMCBarostat_frequency"
, getMCBarostat_frequency_function_value );
}
{ //::SireMove::OpenMMMDIntegrator::getMinimizeIterations
typedef int ( ::SireMove::OpenMMMDIntegrator::*getMinimizeIterations_function_type )( ) ;
getMinimizeIterations_function_type getMinimizeIterations_function_value( &::SireMove::OpenMMMDIntegrator::getMinimizeIterations );
OpenMMMDIntegrator_exposer.def(
"getMinimizeIterations"
, getMinimizeIterations_function_value );
}
{ //::SireMove::OpenMMMDIntegrator::getMinimizeTol
typedef double ( ::SireMove::OpenMMMDIntegrator::*getMinimizeTol_function_type )( ) ;
getMinimizeTol_function_type getMinimizeTol_function_value( &::SireMove::OpenMMMDIntegrator::getMinimizeTol );
OpenMMMDIntegrator_exposer.def(
"getMinimizeTol"
, getMinimizeTol_function_value );
}
{ //::SireMove::OpenMMMDIntegrator::getPlatform
typedef ::QString ( ::SireMove::OpenMMMDIntegrator::*getPlatform_function_type )( ) ;
getPlatform_function_type getPlatform_function_value( &::SireMove::OpenMMMDIntegrator::getPlatform );
OpenMMMDIntegrator_exposer.def(
"getPlatform"
, getPlatform_function_value );
}
{ //::SireMove::OpenMMMDIntegrator::getPotentialEnergy
typedef ::SireUnits::Dimension::MolarEnergy ( ::SireMove::OpenMMMDIntegrator::*getPotentialEnergy_function_type )( ::SireSystem::System const & ) ;
getPotentialEnergy_function_type getPotentialEnergy_function_value( &::SireMove::OpenMMMDIntegrator::getPotentialEnergy );
OpenMMMDIntegrator_exposer.def(
"getPotentialEnergy"
, getPotentialEnergy_function_value
, ( bp::arg("system") ) );
}
{ //::SireMove::OpenMMMDIntegrator::getPrecision
typedef ::QString ( ::SireMove::OpenMMMDIntegrator::*getPrecision_function_type )( ) ;
getPrecision_function_type getPrecision_function_value( &::SireMove::OpenMMMDIntegrator::getPrecision );
OpenMMMDIntegrator_exposer.def(
"getPrecision"
, getPrecision_function_value );
}
{ //::SireMove::OpenMMMDIntegrator::getPressure
typedef ::SireUnits::Dimension::Pressure ( ::SireMove::OpenMMMDIntegrator::*getPressure_function_type )( ) ;
getPressure_function_type getPressure_function_value( &::SireMove::OpenMMMDIntegrator::getPressure );
OpenMMMDIntegrator_exposer.def(
"getPressure"
, getPressure_function_value );
}
{ //::SireMove::OpenMMMDIntegrator::getRestraint
typedef bool ( ::SireMove::OpenMMMDIntegrator::*getRestraint_function_type )( ) ;
getRestraint_function_type getRestraint_function_value( &::SireMove::OpenMMMDIntegrator::getRestraint );
OpenMMMDIntegrator_exposer.def(
"getRestraint"
, getRestraint_function_value );
}
{ //::SireMove::OpenMMMDIntegrator::getTemperature
typedef ::SireUnits::Dimension::Temperature ( ::SireMove::OpenMMMDIntegrator::*getTemperature_function_type )( ) ;
getTemperature_function_type getTemperature_function_value( &::SireMove::OpenMMMDIntegrator::getTemperature );
OpenMMMDIntegrator_exposer.def(
"getTemperature"
, getTemperature_function_value );
}
{ //::SireMove::OpenMMMDIntegrator::getTimetoSkip
typedef ::SireUnits::Dimension::Time ( ::SireMove::OpenMMMDIntegrator::*getTimetoSkip_function_type )( ) ;
getTimetoSkip_function_type getTimetoSkip_function_value( &::SireMove::OpenMMMDIntegrator::getTimetoSkip );
OpenMMMDIntegrator_exposer.def(
"getTimetoSkip"
, getTimetoSkip_function_value );
}
{ //::SireMove::OpenMMMDIntegrator::getTollerandeEwaldPME
typedef double ( ::SireMove::OpenMMMDIntegrator::*getTollerandeEwaldPME_function_type )( ) ;
getTollerandeEwaldPME_function_type getTollerandeEwaldPME_function_value( &::SireMove::OpenMMMDIntegrator::getTollerandeEwaldPME );
OpenMMMDIntegrator_exposer.def(
"getTollerandeEwaldPME"
, getTollerandeEwaldPME_function_value );
}
{ //::SireMove::OpenMMMDIntegrator::initialise
typedef void ( ::SireMove::OpenMMMDIntegrator::*initialise_function_type )( ) ;
initialise_function_type initialise_function_value( &::SireMove::OpenMMMDIntegrator::initialise );
OpenMMMDIntegrator_exposer.def(
"initialise"
, initialise_function_value );
}
{ //::SireMove::OpenMMMDIntegrator::integrate
typedef void ( ::SireMove::OpenMMMDIntegrator::*integrate_function_type )( ::SireMove::IntegratorWorkspace &,::SireCAS::Symbol const &,::SireUnits::Dimension::Time,int,bool ) ;
integrate_function_type integrate_function_value( &::SireMove::OpenMMMDIntegrator::integrate );
OpenMMMDIntegrator_exposer.def(
"integrate"
, integrate_function_value
, ( bp::arg("workspace"), bp::arg("nrg_component"), bp::arg("timestep"), bp::arg("nmoves"), bp::arg("record_stats") ) );
}
{ //::SireMove::OpenMMMDIntegrator::isTimeReversible
typedef bool ( ::SireMove::OpenMMMDIntegrator::*isTimeReversible_function_type )( ) const;
isTimeReversible_function_type isTimeReversible_function_value( &::SireMove::OpenMMMDIntegrator::isTimeReversible );
OpenMMMDIntegrator_exposer.def(
"isTimeReversible"
, isTimeReversible_function_value );
}
OpenMMMDIntegrator_exposer.def( bp::self != bp::self );
{ //::SireMove::OpenMMMDIntegrator::operator=
typedef ::SireMove::OpenMMMDIntegrator & ( ::SireMove::OpenMMMDIntegrator::*assign_function_type )( ::SireMove::OpenMMMDIntegrator const & ) ;
assign_function_type assign_function_value( &::SireMove::OpenMMMDIntegrator::operator= );
OpenMMMDIntegrator_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
OpenMMMDIntegrator_exposer.def( bp::self == bp::self );
{ //::SireMove::OpenMMMDIntegrator::setAndersen
typedef void ( ::SireMove::OpenMMMDIntegrator::*setAndersen_function_type )( bool ) ;
setAndersen_function_type setAndersen_function_value( &::SireMove::OpenMMMDIntegrator::setAndersen );
OpenMMMDIntegrator_exposer.def(
"setAndersen"
, setAndersen_function_value
, ( bp::arg("arg0") ) );
}
{ //::SireMove::OpenMMMDIntegrator::setAndersen_frequency
typedef void ( ::SireMove::OpenMMMDIntegrator::*setAndersen_frequency_function_type )( double ) ;
setAndersen_frequency_function_type setAndersen_frequency_function_value( &::SireMove::OpenMMMDIntegrator::setAndersen_frequency );
OpenMMMDIntegrator_exposer.def(
"setAndersen_frequency"
, setAndersen_frequency_function_value
, ( bp::arg("arg0") ) );
}
{ //::SireMove::OpenMMMDIntegrator::setBufferFrequency
typedef void ( ::SireMove::OpenMMMDIntegrator::*setBufferFrequency_function_type )( int ) ;
setBufferFrequency_function_type setBufferFrequency_function_value( &::SireMove::OpenMMMDIntegrator::setBufferFrequency );
OpenMMMDIntegrator_exposer.def(
"setBufferFrequency"
, setBufferFrequency_function_value
, ( bp::arg("arg0") ) );
}
{ //::SireMove::OpenMMMDIntegrator::setCMMremoval_frequency
typedef void ( ::SireMove::OpenMMMDIntegrator::*setCMMremoval_frequency_function_type )( int ) ;
setCMMremoval_frequency_function_type setCMMremoval_frequency_function_value( &::SireMove::OpenMMMDIntegrator::setCMMremoval_frequency );
OpenMMMDIntegrator_exposer.def(
"setCMMremoval_frequency"
, setCMMremoval_frequency_function_value
, ( bp::arg("arg0") ) );
}
{ //::SireMove::OpenMMMDIntegrator::setConstraintType
typedef void ( ::SireMove::OpenMMMDIntegrator::*setConstraintType_function_type )( ::QString ) ;
setConstraintType_function_type setConstraintType_function_value( &::SireMove::OpenMMMDIntegrator::setConstraintType );
OpenMMMDIntegrator_exposer.def(
"setConstraintType"
, setConstraintType_function_value
, ( bp::arg("arg0") ) );
}
{ //::SireMove::OpenMMMDIntegrator::setCutoffType
typedef void ( ::SireMove::OpenMMMDIntegrator::*setCutoffType_function_type )( ::QString ) ;
setCutoffType_function_type setCutoffType_function_value( &::SireMove::OpenMMMDIntegrator::setCutoffType );
OpenMMMDIntegrator_exposer.def(
"setCutoffType"
, setCutoffType_function_value
, ( bp::arg("arg0") ) );
}
{ //::SireMove::OpenMMMDIntegrator::setCutoff_distance
typedef void ( ::SireMove::OpenMMMDIntegrator::*setCutoff_distance_function_type )( ::SireUnits::Dimension::Length ) ;
setCutoff_distance_function_type setCutoff_distance_function_value( &::SireMove::OpenMMMDIntegrator::setCutoff_distance );
OpenMMMDIntegrator_exposer.def(
"setCutoff_distance"
, setCutoff_distance_function_value
, ( bp::arg("arg0") ) );
}
{ //::SireMove::OpenMMMDIntegrator::setDeviceIndex
typedef void ( ::SireMove::OpenMMMDIntegrator::*setDeviceIndex_function_type )( ::QString ) ;
setDeviceIndex_function_type setDeviceIndex_function_value( &::SireMove::OpenMMMDIntegrator::setDeviceIndex );
OpenMMMDIntegrator_exposer.def(
"setDeviceIndex"
, setDeviceIndex_function_value
, ( bp::arg("arg0") ) );
}
{ //::SireMove::OpenMMMDIntegrator::setEquilib_iterations
typedef void ( ::SireMove::OpenMMMDIntegrator::*setEquilib_iterations_function_type )( int ) ;
setEquilib_iterations_function_type setEquilib_iterations_function_value( &::SireMove::OpenMMMDIntegrator::setEquilib_iterations );
OpenMMMDIntegrator_exposer.def(
"setEquilib_iterations"
, setEquilib_iterations_function_value
, ( bp::arg("arg0") ) );
}
{ //::SireMove::OpenMMMDIntegrator::setEquilib_time_step
typedef void ( ::SireMove::OpenMMMDIntegrator::*setEquilib_time_step_function_type )( ::SireUnits::Dimension::Time ) ;
setEquilib_time_step_function_type setEquilib_time_step_function_value( &::SireMove::OpenMMMDIntegrator::setEquilib_time_step );
OpenMMMDIntegrator_exposer.def(
"setEquilib_time_step"
, setEquilib_time_step_function_value
, ( bp::arg("arg0") ) );
}
{ //::SireMove::OpenMMMDIntegrator::setField_dielectric
typedef void ( ::SireMove::OpenMMMDIntegrator::*setField_dielectric_function_type )( double ) ;
setField_dielectric_function_type setField_dielectric_function_value( &::SireMove::OpenMMMDIntegrator::setField_dielectric );
OpenMMMDIntegrator_exposer.def(
"setField_dielectric"
, setField_dielectric_function_value
, ( bp::arg("arg0") ) );
}
{ //::SireMove::OpenMMMDIntegrator::setFriction
typedef void ( ::SireMove::OpenMMMDIntegrator::*setFriction_function_type )( ::SireUnits::Dimension::Time ) ;
setFriction_function_type setFriction_function_value( &::SireMove::OpenMMMDIntegrator::setFriction );
OpenMMMDIntegrator_exposer.def(
"setFriction"
, setFriction_function_value
, ( bp::arg("arg0") ) );
}
{ //::SireMove::OpenMMMDIntegrator::setIntegration_tollerance
typedef void ( ::SireMove::OpenMMMDIntegrator::*setIntegration_tollerance_function_type )( double ) ;
setIntegration_tollerance_function_type setIntegration_tollerance_function_value( &::SireMove::OpenMMMDIntegrator::setIntegration_tollerance );
OpenMMMDIntegrator_exposer.def(
"setIntegration_tollerance"
, setIntegration_tollerance_function_value
, ( bp::arg("tollerance") ) );
}
{ //::SireMove::OpenMMMDIntegrator::setIntegrator
typedef void ( ::SireMove::OpenMMMDIntegrator::*setIntegrator_function_type )( ::QString ) ;
setIntegrator_function_type setIntegrator_function_value( &::SireMove::OpenMMMDIntegrator::setIntegrator );
OpenMMMDIntegrator_exposer.def(
"setIntegrator"
, setIntegrator_function_value
, ( bp::arg("arg0") ) );
}
{ //::SireMove::OpenMMMDIntegrator::setLJDispersion
typedef void ( ::SireMove::OpenMMMDIntegrator::*setLJDispersion_function_type )( bool ) ;
setLJDispersion_function_type setLJDispersion_function_value( &::SireMove::OpenMMMDIntegrator::setLJDispersion );
OpenMMMDIntegrator_exposer.def(
"setLJDispersion"
, setLJDispersion_function_value
, ( bp::arg("arg0") ) );
}
{ //::SireMove::OpenMMMDIntegrator::setMCBarostat
typedef void ( ::SireMove::OpenMMMDIntegrator::*setMCBarostat_function_type )( bool ) ;
setMCBarostat_function_type setMCBarostat_function_value( &::SireMove::OpenMMMDIntegrator::setMCBarostat );
OpenMMMDIntegrator_exposer.def(
"setMCBarostat"
, setMCBarostat_function_value
, ( bp::arg("arg0") ) );
}
{ //::SireMove::OpenMMMDIntegrator::setMCBarostat_frequency
typedef void ( ::SireMove::OpenMMMDIntegrator::*setMCBarostat_frequency_function_type )( int ) ;
setMCBarostat_frequency_function_type setMCBarostat_frequency_function_value( &::SireMove::OpenMMMDIntegrator::setMCBarostat_frequency );
OpenMMMDIntegrator_exposer.def(
"setMCBarostat_frequency"
, setMCBarostat_frequency_function_value
, ( bp::arg("arg0") ) );
}
{ //::SireMove::OpenMMMDIntegrator::setMinimization
typedef void ( ::SireMove::OpenMMMDIntegrator::*setMinimization_function_type )( bool ) ;
setMinimization_function_type setMinimization_function_value( &::SireMove::OpenMMMDIntegrator::setMinimization );
OpenMMMDIntegrator_exposer.def(
"setMinimization"
, setMinimization_function_value
, ( bp::arg("arg0") ) );
}
{ //::SireMove::OpenMMMDIntegrator::setMinimizeIterations
typedef void ( ::SireMove::OpenMMMDIntegrator::*setMinimizeIterations_function_type )( int ) ;
setMinimizeIterations_function_type setMinimizeIterations_function_value( &::SireMove::OpenMMMDIntegrator::setMinimizeIterations );
OpenMMMDIntegrator_exposer.def(
"setMinimizeIterations"
, setMinimizeIterations_function_value
, ( bp::arg("arg0") ) );
}
{ //::SireMove::OpenMMMDIntegrator::setMinimizeTol
typedef void ( ::SireMove::OpenMMMDIntegrator::*setMinimizeTol_function_type )( double ) ;
setMinimizeTol_function_type setMinimizeTol_function_value( &::SireMove::OpenMMMDIntegrator::setMinimizeTol );
OpenMMMDIntegrator_exposer.def(
"setMinimizeTol"
, setMinimizeTol_function_value
, ( bp::arg("arg0") ) );
}
{ //::SireMove::OpenMMMDIntegrator::setPlatform
typedef void ( ::SireMove::OpenMMMDIntegrator::*setPlatform_function_type )( ::QString ) ;
setPlatform_function_type setPlatform_function_value( &::SireMove::OpenMMMDIntegrator::setPlatform );
OpenMMMDIntegrator_exposer.def(
"setPlatform"
, setPlatform_function_value
, ( bp::arg("arg0") ) );
}
{ //::SireMove::OpenMMMDIntegrator::setPrecision
typedef void ( ::SireMove::OpenMMMDIntegrator::*setPrecision_function_type )( ::QString ) ;
setPrecision_function_type setPrecision_function_value( &::SireMove::OpenMMMDIntegrator::setPrecision );
OpenMMMDIntegrator_exposer.def(
"setPrecision"
, setPrecision_function_value
, ( bp::arg("arg0") ) );
}
{ //::SireMove::OpenMMMDIntegrator::setPressure
typedef void ( ::SireMove::OpenMMMDIntegrator::*setPressure_function_type )( ::SireUnits::Dimension::Pressure ) ;
setPressure_function_type setPressure_function_value( &::SireMove::OpenMMMDIntegrator::setPressure );
OpenMMMDIntegrator_exposer.def(
"setPressure"
, setPressure_function_value
, ( bp::arg("arg0") ) );
}
{ //::SireMove::OpenMMMDIntegrator::setReinitializeContext
typedef void ( ::SireMove::OpenMMMDIntegrator::*setReinitializeContext_function_type )( bool ) ;
setReinitializeContext_function_type setReinitializeContext_function_value( &::SireMove::OpenMMMDIntegrator::setReinitializeContext );
OpenMMMDIntegrator_exposer.def(
"setReinitializeContext"
, setReinitializeContext_function_value
, ( bp::arg("arg0") ) );
}
{ //::SireMove::OpenMMMDIntegrator::setRestraint
typedef void ( ::SireMove::OpenMMMDIntegrator::*setRestraint_function_type )( bool ) ;
setRestraint_function_type setRestraint_function_value( &::SireMove::OpenMMMDIntegrator::setRestraint );
OpenMMMDIntegrator_exposer.def(
"setRestraint"
, setRestraint_function_value
, ( bp::arg("arg0") ) );
}
{ //::SireMove::OpenMMMDIntegrator::setTemperature
typedef void ( ::SireMove::OpenMMMDIntegrator::*setTemperature_function_type )( ::SireUnits::Dimension::Temperature ) ;
setTemperature_function_type setTemperature_function_value( &::SireMove::OpenMMMDIntegrator::setTemperature );
OpenMMMDIntegrator_exposer.def(
"setTemperature"
, setTemperature_function_value
, ( bp::arg("arg0") ) );
}
{ //::SireMove::OpenMMMDIntegrator::setTimetoSkip
typedef void ( ::SireMove::OpenMMMDIntegrator::*setTimetoSkip_function_type )( ::SireUnits::Dimension::Time ) ;
setTimetoSkip_function_type setTimetoSkip_function_value( &::SireMove::OpenMMMDIntegrator::setTimetoSkip );
OpenMMMDIntegrator_exposer.def(
"setTimetoSkip"
, setTimetoSkip_function_value
, ( bp::arg("arg0") ) );
}
{ //::SireMove::OpenMMMDIntegrator::setTollerandeEwaldPME
typedef void ( ::SireMove::OpenMMMDIntegrator::*setTollerandeEwaldPME_function_type )( double ) ;
setTollerandeEwaldPME_function_type setTollerandeEwaldPME_function_value( &::SireMove::OpenMMMDIntegrator::setTollerandeEwaldPME );
OpenMMMDIntegrator_exposer.def(
"setTollerandeEwaldPME"
, setTollerandeEwaldPME_function_value
, ( bp::arg("arg0") ) );
}
{ //::SireMove::OpenMMMDIntegrator::toString
typedef ::QString ( ::SireMove::OpenMMMDIntegrator::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMove::OpenMMMDIntegrator::toString );
OpenMMMDIntegrator_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMove::OpenMMMDIntegrator::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMove::OpenMMMDIntegrator::typeName );
OpenMMMDIntegrator_exposer.def(
"typeName"
, typeName_function_value );
}
OpenMMMDIntegrator_exposer.staticmethod( "typeName" );
OpenMMMDIntegrator_exposer.def( "__copy__", &__copy__);
OpenMMMDIntegrator_exposer.def( "__deepcopy__", &__copy__);
OpenMMMDIntegrator_exposer.def( "clone", &__copy__);
OpenMMMDIntegrator_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMove::OpenMMMDIntegrator >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
OpenMMMDIntegrator_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMove::OpenMMMDIntegrator >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
OpenMMMDIntegrator_exposer.def( "__str__", &__str__< ::SireMove::OpenMMMDIntegrator > );
OpenMMMDIntegrator_exposer.def( "__repr__", &__str__< ::SireMove::OpenMMMDIntegrator > );
}
}
void register_ComponentGradients_class(){
{ //::SireAnalysis::ComponentGradients
typedef bp::class_< SireAnalysis::ComponentGradients, bp::bases< SireBase::Property > > ComponentGradients_exposer_t;
ComponentGradients_exposer_t ComponentGradients_exposer = ComponentGradients_exposer_t( "ComponentGradients", "This class is used to hold the individual free energy gradients\nfor each of the components collected by the SireSystem::FreeEnergyMonitor\nclass\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") );
bp::scope ComponentGradients_scope( ComponentGradients_exposer );
ComponentGradients_exposer.def( bp::init< QMap< double, SireSystem::FreeEnergyMonitor > const &, bp::optional< bool > >(( bp::arg("gradients"), bp::arg("conserve_memory")=(bool)(true) ), "Construct from the passed map of component monitors") );
ComponentGradients_exposer.def( bp::init< QList< SireSystem::FreeEnergyMonitor > const &, bp::optional< bool > >(( bp::arg("gradients"), bp::arg("conserve_memory")=(bool)(true) ), "Construct from the passed list of component monitors") );
ComponentGradients_exposer.def( bp::init< SireAnalysis::ComponentGradients const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireAnalysis::ComponentGradients::conserveMemory
typedef void ( ::SireAnalysis::ComponentGradients::*conserveMemory_function_type)( ) ;
conserveMemory_function_type conserveMemory_function_value( &::SireAnalysis::ComponentGradients::conserveMemory );
ComponentGradients_exposer.def(
"conserveMemory"
, conserveMemory_function_value
, "This function reduces the memory used by this object by ensuring that\nthe FreeEnergyMonitor at each lambda value uses the copy of the\nmolecules used at the first lambda value" );
}
{ //::SireAnalysis::ComponentGradients::conserveMemory
typedef void ( ::SireAnalysis::ComponentGradients::*conserveMemory_function_type)( ::SireAnalysis::ComponentGradients const & ) ;
conserveMemory_function_type conserveMemory_function_value( &::SireAnalysis::ComponentGradients::conserveMemory );
ComponentGradients_exposer.def(
"conserveMemory"
, conserveMemory_function_value
, ( bp::arg("other") )
, "This function conserves memory by copying in all of the shared molecule\ndata etc. from other into this object" );
}
{ //::SireAnalysis::ComponentGradients::coulombGradientsAt
typedef ::SireAnalysis::Gradients ( ::SireAnalysis::ComponentGradients::*coulombGradientsAt_function_type)( int ) const;
coulombGradientsAt_function_type coulombGradientsAt_function_value( &::SireAnalysis::ComponentGradients::coulombGradientsAt );
ComponentGradients_exposer.def(
"coulombGradientsAt"
, coulombGradientsAt_function_value
, ( bp::arg("i") )
, "Return the set of coulomb free energy gradients for the ith free energy component" );
}
{ //::SireAnalysis::ComponentGradients::coulombValues
typedef ::QVector< SireAnalysis::DataPoint > ( ::SireAnalysis::ComponentGradients::*coulombValues_function_type)( int ) const;
coulombValues_function_type coulombValues_function_value( &::SireAnalysis::ComponentGradients::coulombValues );
ComponentGradients_exposer.def(
"coulombValues"
, coulombValues_function_value
, ( bp::arg("i") )
, "Return the actual values of the coulomb free energy gradients of the ith component" );
}
{ //::SireAnalysis::ComponentGradients::data
typedef ::QMap< double, SireSystem::FreeEnergyMonitor > ( ::SireAnalysis::ComponentGradients::*data_function_type)( ) const;
data_function_type data_function_value( &::SireAnalysis::ComponentGradients::data );
ComponentGradients_exposer.def(
"data"
, data_function_value
, "Return the raw data for all of the free energy components" );
}
{ //::SireAnalysis::ComponentGradients::deltaLambda
typedef double ( ::SireAnalysis::ComponentGradients::*deltaLambda_function_type)( ) const;
deltaLambda_function_type deltaLambda_function_value( &::SireAnalysis::ComponentGradients::deltaLambda );
ComponentGradients_exposer.def(
"deltaLambda"
, deltaLambda_function_value
, "Return the value of delta lambda used to approximate the free energy gradients" );
}
{ //::SireAnalysis::ComponentGradients::gradientsAt
typedef ::SireAnalysis::Gradients ( ::SireAnalysis::ComponentGradients::*gradientsAt_function_type)( int ) const;
gradientsAt_function_type gradientsAt_function_value( &::SireAnalysis::ComponentGradients::gradientsAt );
ComponentGradients_exposer.def(
"gradientsAt"
, gradientsAt_function_value
, ( bp::arg("i") )
, "Return the set of free energy gradients for the ith free energy component" );
}
{ //::SireAnalysis::ComponentGradients::integrate
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrate_function_type)( int ) const;
integrate_function_type integrate_function_value( &::SireAnalysis::ComponentGradients::integrate );
ComponentGradients_exposer.def(
"integrate"
, integrate_function_value
, ( bp::arg("i") )
, "Integrate the free energy gradients of the ith component\nand return the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrate
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrate_function_type)( int,int ) const;
integrate_function_type integrate_function_value( &::SireAnalysis::ComponentGradients::integrate );
ComponentGradients_exposer.def(
"integrate"
, integrate_function_value
, ( bp::arg("i"), bp::arg("order") )
, "Integrate the free energy gradients of the ith component to order order and\nreturn the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrate
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrate_function_type)( int,double,double ) const;
integrate_function_type integrate_function_value( &::SireAnalysis::ComponentGradients::integrate );
ComponentGradients_exposer.def(
"integrate"
, integrate_function_value
, ( bp::arg("i"), bp::arg("range_min"), bp::arg("range_max") )
, "Integrate the free energy gradients of the ith component between the range\nrange_min to range_max, and return the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrate
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrate_function_type)( int,double,double,int ) const;
integrate_function_type integrate_function_value( &::SireAnalysis::ComponentGradients::integrate );
ComponentGradients_exposer.def(
"integrate"
, integrate_function_value
, ( bp::arg("i"), bp::arg("range_min"), bp::arg("range_max"), bp::arg("order") )
, "Integrate the free energy gradients of the ith component to order order\nbetween the range range_min to range_max and return the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrateCoulomb
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrateCoulomb_function_type)( int ) const;
integrateCoulomb_function_type integrateCoulomb_function_value( &::SireAnalysis::ComponentGradients::integrateCoulomb );
ComponentGradients_exposer.def(
"integrateCoulomb"
, integrateCoulomb_function_value
, ( bp::arg("i") )
, "Integrate the coulomb free energy gradients of the ith component\nand return the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrateCoulomb
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrateCoulomb_function_type)( int,int ) const;
integrateCoulomb_function_type integrateCoulomb_function_value( &::SireAnalysis::ComponentGradients::integrateCoulomb );
ComponentGradients_exposer.def(
"integrateCoulomb"
, integrateCoulomb_function_value
, ( bp::arg("i"), bp::arg("order") )
, "Integrate the coulomb free energy gradients of the ith component to order order and\nreturn the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrateCoulomb
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrateCoulomb_function_type)( int,double,double ) const;
integrateCoulomb_function_type integrateCoulomb_function_value( &::SireAnalysis::ComponentGradients::integrateCoulomb );
ComponentGradients_exposer.def(
"integrateCoulomb"
, integrateCoulomb_function_value
, ( bp::arg("i"), bp::arg("range_min"), bp::arg("range_max") )
, "Integrate the coulomb free energy gradients of the ith component between the range\nrange_min to range_max, and return the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrateCoulomb
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrateCoulomb_function_type)( int,double,double,int ) const;
integrateCoulomb_function_type integrateCoulomb_function_value( &::SireAnalysis::ComponentGradients::integrateCoulomb );
ComponentGradients_exposer.def(
"integrateCoulomb"
, integrateCoulomb_function_value
, ( bp::arg("i"), bp::arg("range_min"), bp::arg("range_max"), bp::arg("order") )
, "Integrate the coulomb free energy gradients of the ith component to order order\nbetween the range range_min to range_max and return the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrateLJ
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrateLJ_function_type)( int ) const;
integrateLJ_function_type integrateLJ_function_value( &::SireAnalysis::ComponentGradients::integrateLJ );
ComponentGradients_exposer.def(
"integrateLJ"
, integrateLJ_function_value
, ( bp::arg("i") )
, "Integrate the LJ free energy gradients of the ith component\nand return the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrateLJ
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrateLJ_function_type)( int,int ) const;
integrateLJ_function_type integrateLJ_function_value( &::SireAnalysis::ComponentGradients::integrateLJ );
ComponentGradients_exposer.def(
"integrateLJ"
, integrateLJ_function_value
, ( bp::arg("i"), bp::arg("order") )
, "Integrate the LJ free energy gradients of the ith component to order order and\nreturn the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrateLJ
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrateLJ_function_type)( int,double,double ) const;
integrateLJ_function_type integrateLJ_function_value( &::SireAnalysis::ComponentGradients::integrateLJ );
ComponentGradients_exposer.def(
"integrateLJ"
, integrateLJ_function_value
, ( bp::arg("i"), bp::arg("range_min"), bp::arg("range_max") )
, "Integrate the LJ free energy gradients of the ith component between the range\nrange_min to range_max, and return the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrateLJ
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrateLJ_function_type)( int,double,double,int ) const;
integrateLJ_function_type integrateLJ_function_value( &::SireAnalysis::ComponentGradients::integrateLJ );
ComponentGradients_exposer.def(
"integrateLJ"
, integrateLJ_function_value
, ( bp::arg("i"), bp::arg("range_min"), bp::arg("range_max"), bp::arg("order") )
, "Integrate the LJ free energy gradients of the ith component to order order\nbetween the range range_min to range_max and return the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::isCompatible
typedef bool ( ::SireAnalysis::ComponentGradients::*isCompatible_function_type)( ::SireAnalysis::ComponentGradients const & ) const;
isCompatible_function_type isCompatible_function_value( &::SireAnalysis::ComponentGradients::isCompatible );
ComponentGradients_exposer.def(
"isCompatible"
, isCompatible_function_value
, ( bp::arg("other") )
, "Return whether or not this set of gradients is compatible with the ones\nprovided in other" );
}
{ //::SireAnalysis::ComponentGradients::isEmpty
typedef bool ( ::SireAnalysis::ComponentGradients::*isEmpty_function_type)( ) const;
isEmpty_function_type isEmpty_function_value( &::SireAnalysis::ComponentGradients::isEmpty );
ComponentGradients_exposer.def(
"isEmpty"
, isEmpty_function_value
, "Return whether or not this set is empty" );
}
{ //::SireAnalysis::ComponentGradients::lambdaValues
typedef ::QList< double > ( ::SireAnalysis::ComponentGradients::*lambdaValues_function_type)( ) const;
lambdaValues_function_type lambdaValues_function_value( &::SireAnalysis::ComponentGradients::lambdaValues );
ComponentGradients_exposer.def(
"lambdaValues"
, lambdaValues_function_value
, "Return the lambda values over which all of the components were collected" );
}
{ //::SireAnalysis::ComponentGradients::ljGradientsAt
typedef ::SireAnalysis::Gradients ( ::SireAnalysis::ComponentGradients::*ljGradientsAt_function_type)( int ) const;
ljGradientsAt_function_type ljGradientsAt_function_value( &::SireAnalysis::ComponentGradients::ljGradientsAt );
ComponentGradients_exposer.def(
"ljGradientsAt"
, ljGradientsAt_function_value
, ( bp::arg("i") )
, "Return the set of LJ free energy gradients for the ith free energy component" );
}
{ //::SireAnalysis::ComponentGradients::ljValues
typedef ::QVector< SireAnalysis::DataPoint > ( ::SireAnalysis::ComponentGradients::*ljValues_function_type)( int ) const;
ljValues_function_type ljValues_function_value( &::SireAnalysis::ComponentGradients::ljValues );
ComponentGradients_exposer.def(
"ljValues"
, ljValues_function_value
, ( bp::arg("i") )
, "Return the actual values of the LJ free energy gradients of the ith component" );
}
{ //::SireAnalysis::ComponentGradients::merge
typedef ::SireAnalysis::ComponentGradients ( *merge_function_type )( ::QList< SireAnalysis::ComponentGradients > const & );
merge_function_type merge_function_value( &::SireAnalysis::ComponentGradients::merge );
ComponentGradients_exposer.def(
"merge"
, merge_function_value
, ( bp::arg("gradients") )
, "Merge together all of the passed gradients. Note that they must all be compatible\nwith one another, otherwise an exception will be raised" );
}
{ //::SireAnalysis::ComponentGradients::nComponents
typedef int ( ::SireAnalysis::ComponentGradients::*nComponents_function_type)( ) const;
nComponents_function_type nComponents_function_value( &::SireAnalysis::ComponentGradients::nComponents );
ComponentGradients_exposer.def(
"nComponents"
, nComponents_function_value
, "Return the number of free energy components (number of molecule views whose\nfree energy of interaction was recorded)" );
}
{ //::SireAnalysis::ComponentGradients::nLambdaValues
typedef int ( ::SireAnalysis::ComponentGradients::*nLambdaValues_function_type)( ) const;
nLambdaValues_function_type nLambdaValues_function_value( &::SireAnalysis::ComponentGradients::nLambdaValues );
ComponentGradients_exposer.def(
"nLambdaValues"
, nLambdaValues_function_value
, "Return the number of lambda values over which the free energy components have\nbeen recorded" );
}
{ //::SireAnalysis::ComponentGradients::nSamples
typedef ::qint64 ( ::SireAnalysis::ComponentGradients::*nSamples_function_type)( ) const;
nSamples_function_type nSamples_function_value( &::SireAnalysis::ComponentGradients::nSamples );
ComponentGradients_exposer.def(
"nSamples"
, nSamples_function_value
, "Return the number of samples used to form all of the average components" );
}
ComponentGradients_exposer.def( bp::self != bp::self );
ComponentGradients_exposer.def( bp::self + bp::self );
{ //::SireAnalysis::ComponentGradients::operator=
typedef ::SireAnalysis::ComponentGradients & ( ::SireAnalysis::ComponentGradients::*assign_function_type)( ::SireAnalysis::ComponentGradients const & ) ;
assign_function_type assign_function_value( &::SireAnalysis::ComponentGradients::operator= );
ComponentGradients_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
ComponentGradients_exposer.def( bp::self == bp::self );
{ //::SireAnalysis::ComponentGradients::temperature
typedef ::SireUnits::Dimension::Temperature ( ::SireAnalysis::ComponentGradients::*temperature_function_type)( ) const;
temperature_function_type temperature_function_value( &::SireAnalysis::ComponentGradients::temperature );
ComponentGradients_exposer.def(
"temperature"
, temperature_function_value
, "Return the temperature at which all of the components were collected" );
}
{ //::SireAnalysis::ComponentGradients::toString
typedef ::QString ( ::SireAnalysis::ComponentGradients::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireAnalysis::ComponentGradients::toString );
ComponentGradients_exposer.def(
"toString"
, toString_function_value
, "" );
}
{ //::SireAnalysis::ComponentGradients::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireAnalysis::ComponentGradients::typeName );
ComponentGradients_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireAnalysis::ComponentGradients::values
typedef ::QVector< SireAnalysis::DataPoint > ( ::SireAnalysis::ComponentGradients::*values_function_type)( int ) const;
values_function_type values_function_value( &::SireAnalysis::ComponentGradients::values );
ComponentGradients_exposer.def(
"values"
, values_function_value
, ( bp::arg("i") )
, "Return the actual values of the free energy gradients of the ith component" );
}
{ //::SireAnalysis::ComponentGradients::viewAt
typedef ::SireMol::PartialMolecule ( ::SireAnalysis::ComponentGradients::*viewAt_function_type)( int ) const;
viewAt_function_type viewAt_function_value( &::SireAnalysis::ComponentGradients::viewAt );
ComponentGradients_exposer.def(
"viewAt"
, viewAt_function_value
, ( bp::arg("i") )
, "Return the ith view that corresponds to the ith free energy component.\nNote that this returns the view in the numerically first (lowest) lambda\nvalue. Use viewAt(int i, double lamval) if you want to specify the lambda\nvalue from which you want to extract the view." );
}
{ //::SireAnalysis::ComponentGradients::viewAt
typedef ::SireMol::PartialMolecule ( ::SireAnalysis::ComponentGradients::*viewAt_function_type)( int,double ) const;
viewAt_function_type viewAt_function_value( &::SireAnalysis::ComponentGradients::viewAt );
ComponentGradients_exposer.def(
"viewAt"
, viewAt_function_value
, ( bp::arg("i"), bp::arg("lamval") )
, "Return the ith view from lambda value lamval that corresponds to the\nith free energy component." );
}
{ //::SireAnalysis::ComponentGradients::what
typedef char const * ( ::SireAnalysis::ComponentGradients::*what_function_type)( ) const;
what_function_type what_function_value( &::SireAnalysis::ComponentGradients::what );
ComponentGradients_exposer.def(
"what"
, what_function_value
, "" );
}
ComponentGradients_exposer.staticmethod( "merge" );
ComponentGradients_exposer.staticmethod( "typeName" );
ComponentGradients_exposer.def( "__copy__", &__copy__);
ComponentGradients_exposer.def( "__deepcopy__", &__copy__);
ComponentGradients_exposer.def( "clone", &__copy__);
ComponentGradients_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireAnalysis::ComponentGradients >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ComponentGradients_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireAnalysis::ComponentGradients >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ComponentGradients_exposer.def( "__str__", &__str__< ::SireAnalysis::ComponentGradients > );
ComponentGradients_exposer.def( "__repr__", &__str__< ::SireAnalysis::ComponentGradients > );
}
}
void register_ExpressionBase_class(){
{ //::SireCAS::ExpressionBase
typedef bp::class_< SireCAS::ExpressionBase > ExpressionBase_exposer_t;
ExpressionBase_exposer_t ExpressionBase_exposer = ExpressionBase_exposer_t( "ExpressionBase", bp::init< >() );
bp::scope ExpressionBase_scope( ExpressionBase_exposer );
ExpressionBase_exposer.def( bp::init< SireCAS::ExBase const & >(( bp::arg("ex") )) );
ExpressionBase_exposer.def( bp::init< SireCAS::ExpressionBase const & >(( bp::arg("other") )) );
{ //::SireCAS::ExpressionBase::children
typedef ::SireCAS::Expressions ( ::SireCAS::ExpressionBase::*children_function_type )( ) const;
children_function_type children_function_value( &::SireCAS::ExpressionBase::children );
ExpressionBase_exposer.def(
"children"
, children_function_value );
}
{ //::SireCAS::ExpressionBase::conjugate
typedef ::SireCAS::Expression ( ::SireCAS::ExpressionBase::*conjugate_function_type )( ) const;
conjugate_function_type conjugate_function_value( &::SireCAS::ExpressionBase::conjugate );
ExpressionBase_exposer.def(
"conjugate"
, conjugate_function_value );
}
{ //::SireCAS::ExpressionBase::differentiate
typedef ::SireCAS::Expression ( ::SireCAS::ExpressionBase::*differentiate_function_type )( ::SireCAS::Symbol const & ) const;
differentiate_function_type differentiate_function_value( &::SireCAS::ExpressionBase::differentiate );
ExpressionBase_exposer.def(
"differentiate"
, differentiate_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireCAS::ExpressionBase::evaluate
typedef double ( ::SireCAS::ExpressionBase::*evaluate_function_type )( ::SireCAS::Values const & ) const;
evaluate_function_type evaluate_function_value( &::SireCAS::ExpressionBase::evaluate );
ExpressionBase_exposer.def(
"evaluate"
, evaluate_function_value
, ( bp::arg("values") ) );
}
{ //::SireCAS::ExpressionBase::evaluate
typedef ::SireMaths::Complex ( ::SireCAS::ExpressionBase::*evaluate_function_type )( ::SireCAS::ComplexValues const & ) const;
evaluate_function_type evaluate_function_value( &::SireCAS::ExpressionBase::evaluate );
ExpressionBase_exposer.def(
"evaluate"
, evaluate_function_value
, ( bp::arg("values") ) );
}
{ //::SireCAS::ExpressionBase::expand
typedef ::QList< SireCAS::Factor > ( ::SireCAS::ExpressionBase::*expand_function_type )( ::SireCAS::Symbol const & ) const;
expand_function_type expand_function_value( &::SireCAS::ExpressionBase::expand );
ExpressionBase_exposer.def(
"expand"
, expand_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireCAS::ExpressionBase::functions
typedef ::SireCAS::Functions ( ::SireCAS::ExpressionBase::*functions_function_type )( ) const;
functions_function_type functions_function_value( &::SireCAS::ExpressionBase::functions );
ExpressionBase_exposer.def(
"functions"
, functions_function_value );
}
{ //::SireCAS::ExpressionBase::hash
typedef ::uint ( ::SireCAS::ExpressionBase::*hash_function_type )( ) const;
hash_function_type hash_function_value( &::SireCAS::ExpressionBase::hash );
ExpressionBase_exposer.def(
"hash"
, hash_function_value );
}
{ //::SireCAS::ExpressionBase::integrate
typedef ::SireCAS::Expression ( ::SireCAS::ExpressionBase::*integrate_function_type )( ::SireCAS::Symbol const & ) const;
integrate_function_type integrate_function_value( &::SireCAS::ExpressionBase::integrate );
ExpressionBase_exposer.def(
"integrate"
, integrate_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireCAS::ExpressionBase::isComplex
typedef bool ( ::SireCAS::ExpressionBase::*isComplex_function_type )( ) const;
isComplex_function_type isComplex_function_value( &::SireCAS::ExpressionBase::isComplex );
ExpressionBase_exposer.def(
"isComplex"
, isComplex_function_value );
}
{ //::SireCAS::ExpressionBase::isCompound
typedef bool ( ::SireCAS::ExpressionBase::*isCompound_function_type )( ) const;
isCompound_function_type isCompound_function_value( &::SireCAS::ExpressionBase::isCompound );
ExpressionBase_exposer.def(
"isCompound"
, isCompound_function_value );
}
{ //::SireCAS::ExpressionBase::isConstant
typedef bool ( ::SireCAS::ExpressionBase::*isConstant_function_type )( ) const;
isConstant_function_type isConstant_function_value( &::SireCAS::ExpressionBase::isConstant );
ExpressionBase_exposer.def(
"isConstant"
, isConstant_function_value );
}
{ //::SireCAS::ExpressionBase::isFunction
typedef bool ( ::SireCAS::ExpressionBase::*isFunction_function_type )( ::SireCAS::Symbol const & ) const;
isFunction_function_type isFunction_function_value( &::SireCAS::ExpressionBase::isFunction );
ExpressionBase_exposer.def(
"isFunction"
, isFunction_function_value
, ( bp::arg("arg0") ) );
}
ExpressionBase_exposer.def( bp::self != bp::self );
{ //::SireCAS::ExpressionBase::operator=
typedef ::SireCAS::ExpressionBase & ( ::SireCAS::ExpressionBase::*assign_function_type )( ::SireCAS::ExpressionBase const & ) ;
assign_function_type assign_function_value( &::SireCAS::ExpressionBase::operator= );
ExpressionBase_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
{ //::SireCAS::ExpressionBase::operator=
typedef ::SireCAS::ExpressionBase & ( ::SireCAS::ExpressionBase::*assign_function_type )( ::SireCAS::ExBase const & ) ;
assign_function_type assign_function_value( &::SireCAS::ExpressionBase::operator= );
ExpressionBase_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
ExpressionBase_exposer.def( bp::self == bp::self );
{ //::SireCAS::ExpressionBase::series
typedef ::SireCAS::Expression ( ::SireCAS::ExpressionBase::*series_function_type )( ::SireCAS::Symbol const &,int ) const;
series_function_type series_function_value( &::SireCAS::ExpressionBase::series );
ExpressionBase_exposer.def(
"series"
, series_function_value
, ( bp::arg("symbol"), bp::arg("n") ) );
}
{ //::SireCAS::ExpressionBase::simplify
typedef ::SireCAS::Expression ( ::SireCAS::ExpressionBase::*simplify_function_type )( int ) const;
simplify_function_type simplify_function_value( &::SireCAS::ExpressionBase::simplify );
ExpressionBase_exposer.def(
"simplify"
, simplify_function_value
, ( bp::arg("options")=(int)(0) ) );
}
{ //::SireCAS::ExpressionBase::substitute
typedef ::SireCAS::Expression ( ::SireCAS::ExpressionBase::*substitute_function_type )( ::SireCAS::Identities const & ) const;
substitute_function_type substitute_function_value( &::SireCAS::ExpressionBase::substitute );
ExpressionBase_exposer.def(
"substitute"
, substitute_function_value
, ( bp::arg("identities") ) );
}
{ //::SireCAS::ExpressionBase::symbols
typedef ::SireCAS::Symbols ( ::SireCAS::ExpressionBase::*symbols_function_type )( ) const;
symbols_function_type symbols_function_value( &::SireCAS::ExpressionBase::symbols );
ExpressionBase_exposer.def(
"symbols"
, symbols_function_value );
}
{ //::SireCAS::ExpressionBase::toString
typedef ::QString ( ::SireCAS::ExpressionBase::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireCAS::ExpressionBase::toString );
ExpressionBase_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireCAS::ExpressionBase::what
typedef char const * ( ::SireCAS::ExpressionBase::*what_function_type )( ) const;
what_function_type what_function_value( &::SireCAS::ExpressionBase::what );
ExpressionBase_exposer.def(
"what"
, what_function_value );
}
ExpressionBase_exposer.def( "__copy__", &__copy__);
ExpressionBase_exposer.def( "__deepcopy__", &__copy__);
ExpressionBase_exposer.def( "clone", &__copy__);
ExpressionBase_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::ExpressionBase >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ExpressionBase_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::ExpressionBase >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ExpressionBase_exposer.def( "__str__", &__str__< ::SireCAS::ExpressionBase > );
ExpressionBase_exposer.def( "__repr__", &__str__< ::SireCAS::ExpressionBase > );
}
}
void register_BennettsRatios_class(){
{ //::SireAnalysis::BennettsRatios
typedef bp::class_< SireAnalysis::BennettsRatios, bp::bases< SireBase::Property > > BennettsRatios_exposer_t;
BennettsRatios_exposer_t BennettsRatios_exposer = BennettsRatios_exposer_t( "BennettsRatios", bp::init< >() );
bp::scope BennettsRatios_scope( BennettsRatios_exposer );
BennettsRatios_exposer.def( bp::init< QList< double > const &, QMap< double, SireMaths::BennettsFreeEnergyAverage > const &, QMap< double, SireMaths::BennettsFreeEnergyAverage > const & >(( bp::arg("windows"), bp::arg("forwards_ratios"), bp::arg("backwards_ratios") )) );
BennettsRatios_exposer.def( bp::init< SireAnalysis::BennettsRatios const & >(( bp::arg("other") )) );
{ //::SireAnalysis::BennettsRatios::backwardsData
typedef ::QMap< double, SireMaths::BennettsFreeEnergyAverage > ( ::SireAnalysis::BennettsRatios::*backwardsData_function_type )( ) const;
backwardsData_function_type backwardsData_function_value( &::SireAnalysis::BennettsRatios::backwardsData );
BennettsRatios_exposer.def(
"backwardsData"
, backwardsData_function_value );
}
{ //::SireAnalysis::BennettsRatios::backwardsRatios
typedef ::QMap< double, SireMaths::BennettsFreeEnergyAverage > ( ::SireAnalysis::BennettsRatios::*backwardsRatios_function_type )( ) const;
backwardsRatios_function_type backwardsRatios_function_value( &::SireAnalysis::BennettsRatios::backwardsRatios );
BennettsRatios_exposer.def(
"backwardsRatios"
, backwardsRatios_function_value );
}
{ //::SireAnalysis::BennettsRatios::constants
typedef ::QVector< SireAnalysis::DataPoint > ( ::SireAnalysis::BennettsRatios::*constants_function_type )( ) const;
constants_function_type constants_function_value( &::SireAnalysis::BennettsRatios::constants );
BennettsRatios_exposer.def(
"constants"
, constants_function_value );
}
{ //::SireAnalysis::BennettsRatios::denominators
typedef ::QVector< SireAnalysis::DataPoint > ( ::SireAnalysis::BennettsRatios::*denominators_function_type )( ) const;
denominators_function_type denominators_function_value( &::SireAnalysis::BennettsRatios::denominators );
BennettsRatios_exposer.def(
"denominators"
, denominators_function_value );
}
{ //::SireAnalysis::BennettsRatios::forwardsData
typedef ::QMap< double, SireMaths::BennettsFreeEnergyAverage > ( ::SireAnalysis::BennettsRatios::*forwardsData_function_type )( ) const;
forwardsData_function_type forwardsData_function_value( &::SireAnalysis::BennettsRatios::forwardsData );
BennettsRatios_exposer.def(
"forwardsData"
, forwardsData_function_value );
}
{ //::SireAnalysis::BennettsRatios::forwardsRatios
typedef ::QMap< double, SireMaths::BennettsFreeEnergyAverage > ( ::SireAnalysis::BennettsRatios::*forwardsRatios_function_type )( ) const;
forwardsRatios_function_type forwardsRatios_function_value( &::SireAnalysis::BennettsRatios::forwardsRatios );
BennettsRatios_exposer.def(
"forwardsRatios"
, forwardsRatios_function_value );
}
{ //::SireAnalysis::BennettsRatios::integrate
typedef ::SireAnalysis::PMF ( ::SireAnalysis::BennettsRatios::*integrate_function_type )( ) const;
integrate_function_type integrate_function_value( &::SireAnalysis::BennettsRatios::integrate );
BennettsRatios_exposer.def(
"integrate"
, integrate_function_value );
}
{ //::SireAnalysis::BennettsRatios::isEmpty
typedef bool ( ::SireAnalysis::BennettsRatios::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireAnalysis::BennettsRatios::isEmpty );
BennettsRatios_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireAnalysis::BennettsRatios::lambdaValues
typedef ::QList< double > ( ::SireAnalysis::BennettsRatios::*lambdaValues_function_type )( ) const;
lambdaValues_function_type lambdaValues_function_value( &::SireAnalysis::BennettsRatios::lambdaValues );
BennettsRatios_exposer.def(
"lambdaValues"
, lambdaValues_function_value );
}
{ //::SireAnalysis::BennettsRatios::merge
typedef ::SireAnalysis::BennettsRatios ( *merge_function_type )( ::QList< SireAnalysis::BennettsRatios > const & );
merge_function_type merge_function_value( &::SireAnalysis::BennettsRatios::merge );
BennettsRatios_exposer.def(
"merge"
, merge_function_value
, ( bp::arg("deltas") ) );
}
{ //::SireAnalysis::BennettsRatios::nLambdaValues
typedef int ( ::SireAnalysis::BennettsRatios::*nLambdaValues_function_type )( ) const;
nLambdaValues_function_type nLambdaValues_function_value( &::SireAnalysis::BennettsRatios::nLambdaValues );
BennettsRatios_exposer.def(
"nLambdaValues"
, nLambdaValues_function_value );
}
{ //::SireAnalysis::BennettsRatios::nSamples
typedef ::qint64 ( ::SireAnalysis::BennettsRatios::*nSamples_function_type )( ) const;
nSamples_function_type nSamples_function_value( &::SireAnalysis::BennettsRatios::nSamples );
BennettsRatios_exposer.def(
"nSamples"
, nSamples_function_value );
}
{ //::SireAnalysis::BennettsRatios::nWindows
typedef int ( ::SireAnalysis::BennettsRatios::*nWindows_function_type )( ) const;
nWindows_function_type nWindows_function_value( &::SireAnalysis::BennettsRatios::nWindows );
BennettsRatios_exposer.def(
"nWindows"
, nWindows_function_value );
}
{ //::SireAnalysis::BennettsRatios::numerators
typedef ::QVector< SireAnalysis::DataPoint > ( ::SireAnalysis::BennettsRatios::*numerators_function_type )( ) const;
numerators_function_type numerators_function_value( &::SireAnalysis::BennettsRatios::numerators );
BennettsRatios_exposer.def(
"numerators"
, numerators_function_value );
}
BennettsRatios_exposer.def( bp::self != bp::self );
BennettsRatios_exposer.def( bp::self + bp::self );
{ //::SireAnalysis::BennettsRatios::operator=
typedef ::SireAnalysis::BennettsRatios & ( ::SireAnalysis::BennettsRatios::*assign_function_type )( ::SireAnalysis::BennettsRatios const & ) ;
assign_function_type assign_function_value( &::SireAnalysis::BennettsRatios::operator= );
BennettsRatios_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
BennettsRatios_exposer.def( bp::self == bp::self );
{ //::SireAnalysis::BennettsRatios::sum
typedef ::SireAnalysis::PMF ( ::SireAnalysis::BennettsRatios::*sum_function_type )( ) const;
sum_function_type sum_function_value( &::SireAnalysis::BennettsRatios::sum );
BennettsRatios_exposer.def(
"sum"
, sum_function_value );
}
{ //::SireAnalysis::BennettsRatios::temperature
typedef ::SireUnits::Dimension::Temperature ( ::SireAnalysis::BennettsRatios::*temperature_function_type )( ) const;
temperature_function_type temperature_function_value( &::SireAnalysis::BennettsRatios::temperature );
BennettsRatios_exposer.def(
"temperature"
, temperature_function_value );
}
{ //::SireAnalysis::BennettsRatios::toString
typedef ::QString ( ::SireAnalysis::BennettsRatios::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireAnalysis::BennettsRatios::toString );
BennettsRatios_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireAnalysis::BennettsRatios::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireAnalysis::BennettsRatios::typeName );
BennettsRatios_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireAnalysis::BennettsRatios::values
typedef ::QVector< SireAnalysis::DataPoint > ( ::SireAnalysis::BennettsRatios::*values_function_type )( ) const;
values_function_type values_function_value( &::SireAnalysis::BennettsRatios::values );
BennettsRatios_exposer.def(
"values"
, values_function_value );
}
{ //::SireAnalysis::BennettsRatios::what
typedef char const * ( ::SireAnalysis::BennettsRatios::*what_function_type )( ) const;
what_function_type what_function_value( &::SireAnalysis::BennettsRatios::what );
BennettsRatios_exposer.def(
"what"
, what_function_value );
}
{ //::SireAnalysis::BennettsRatios::windows
typedef ::QList< double > ( ::SireAnalysis::BennettsRatios::*windows_function_type )( ) const;
windows_function_type windows_function_value( &::SireAnalysis::BennettsRatios::windows );
BennettsRatios_exposer.def(
"windows"
, windows_function_value );
}
BennettsRatios_exposer.staticmethod( "merge" );
BennettsRatios_exposer.staticmethod( "typeName" );
BennettsRatios_exposer.def( "__copy__", &__copy__);
BennettsRatios_exposer.def( "__deepcopy__", &__copy__);
BennettsRatios_exposer.def( "clone", &__copy__);
BennettsRatios_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireAnalysis::BennettsRatios >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
BennettsRatios_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireAnalysis::BennettsRatios >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
BennettsRatios_exposer.def( "__str__", &__str__< ::SireAnalysis::BennettsRatios > );
BennettsRatios_exposer.def( "__repr__", &__str__< ::SireAnalysis::BennettsRatios > );
}
}
void register_Conditional_class(){
{ //::SireCAS::Conditional
typedef bp::class_< SireCAS::Conditional, bp::bases< SireCAS::ExBase > > Conditional_exposer_t;
Conditional_exposer_t Conditional_exposer = Conditional_exposer_t( "Conditional", "This is a conditional expression. If the condition is true,\nthen true_expression is evaluated, else if the condition\nis false then false_expression is evaluate\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") );
bp::scope Conditional_scope( Conditional_exposer );
Conditional_exposer.def( bp::init< SireCAS::Condition const &, SireCAS::Expression const &, SireCAS::Expression const & >(( bp::arg("condition"), bp::arg("true_expression"), bp::arg("false_expression") ), "Construct a conditional where if condition is true, then\ntrue_expression is evaluated, while if condition is false,\nthen false_expression is evaluated") );
Conditional_exposer.def( bp::init< SireCAS::Conditional const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireCAS::Conditional::children
typedef ::SireCAS::Expressions ( ::SireCAS::Conditional::*children_function_type)( ) const;
children_function_type children_function_value( &::SireCAS::Conditional::children );
Conditional_exposer.def(
"children"
, children_function_value
, "Return the children of this expression" );
}
{ //::SireCAS::Conditional::condition
typedef ::SireCAS::Condition const & ( ::SireCAS::Conditional::*condition_function_type)( ) const;
condition_function_type condition_function_value( &::SireCAS::Conditional::condition );
Conditional_exposer.def(
"condition"
, condition_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the condition" );
}
{ //::SireCAS::Conditional::conjugate
typedef ::SireCAS::Expression ( ::SireCAS::Conditional::*conjugate_function_type)( ) const;
conjugate_function_type conjugate_function_value( &::SireCAS::Conditional::conjugate );
Conditional_exposer.def(
"conjugate"
, conjugate_function_value
, "Return the complex conjugate of this expression" );
}
{ //::SireCAS::Conditional::differentiate
typedef ::SireCAS::Expression ( ::SireCAS::Conditional::*differentiate_function_type)( ::SireCAS::Symbol const & ) const;
differentiate_function_type differentiate_function_value( &::SireCAS::Conditional::differentiate );
Conditional_exposer.def(
"differentiate"
, differentiate_function_value
, ( bp::arg("symbol") )
, "Return the differential of this expression" );
}
{ //::SireCAS::Conditional::evaluate
typedef double ( ::SireCAS::Conditional::*evaluate_function_type)( ::SireCAS::Values const & ) const;
evaluate_function_type evaluate_function_value( &::SireCAS::Conditional::evaluate );
Conditional_exposer.def(
"evaluate"
, evaluate_function_value
, ( bp::arg("values") )
, "Evaluate this expression for the passed values" );
}
{ //::SireCAS::Conditional::evaluate
typedef ::SireMaths::Complex ( ::SireCAS::Conditional::*evaluate_function_type)( ::SireCAS::ComplexValues const & ) const;
evaluate_function_type evaluate_function_value( &::SireCAS::Conditional::evaluate );
Conditional_exposer.def(
"evaluate"
, evaluate_function_value
, ( bp::arg("values") )
, "Evaluate this expresion for the passed values" );
}
{ //::SireCAS::Conditional::expand
typedef ::QList< SireCAS::Factor > ( ::SireCAS::Conditional::*expand_function_type)( ::SireCAS::Symbol const & ) const;
expand_function_type expand_function_value( &::SireCAS::Conditional::expand );
Conditional_exposer.def(
"expand"
, expand_function_value
, ( bp::arg("symbol") )
, "Expand this expression in terms of symbol" );
}
{ //::SireCAS::Conditional::falseExpression
typedef ::SireCAS::Expression const & ( ::SireCAS::Conditional::*falseExpression_function_type)( ) const;
falseExpression_function_type falseExpression_function_value( &::SireCAS::Conditional::falseExpression );
Conditional_exposer.def(
"falseExpression"
, falseExpression_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the expression to be evaluated if the condition is false" );
}
{ //::SireCAS::Conditional::functions
typedef ::SireCAS::Functions ( ::SireCAS::Conditional::*functions_function_type)( ) const;
functions_function_type functions_function_value( &::SireCAS::Conditional::functions );
Conditional_exposer.def(
"functions"
, functions_function_value
, "Return the functions used in this expression" );
}
{ //::SireCAS::Conditional::hash
typedef ::uint ( ::SireCAS::Conditional::*hash_function_type)( ) const;
hash_function_type hash_function_value( &::SireCAS::Conditional::hash );
Conditional_exposer.def(
"hash"
, hash_function_value
, "Hash this conditional" );
}
{ //::SireCAS::Conditional::integrate
typedef ::SireCAS::Expression ( ::SireCAS::Conditional::*integrate_function_type)( ::SireCAS::Symbol const & ) const;
integrate_function_type integrate_function_value( &::SireCAS::Conditional::integrate );
Conditional_exposer.def(
"integrate"
, integrate_function_value
, ( bp::arg("symbol") )
, "Return the integral of this expression" );
}
{ //::SireCAS::Conditional::isComplex
typedef bool ( ::SireCAS::Conditional::*isComplex_function_type)( ) const;
isComplex_function_type isComplex_function_value( &::SireCAS::Conditional::isComplex );
Conditional_exposer.def(
"isComplex"
, isComplex_function_value
, "Is this a complex expression?" );
}
{ //::SireCAS::Conditional::isCompound
typedef bool ( ::SireCAS::Conditional::*isCompound_function_type)( ) const;
isCompound_function_type isCompound_function_value( &::SireCAS::Conditional::isCompound );
Conditional_exposer.def(
"isCompound"
, isCompound_function_value
, "Is this a compound expression?" );
}
{ //::SireCAS::Conditional::isConstant
typedef bool ( ::SireCAS::Conditional::*isConstant_function_type)( ) const;
isConstant_function_type isConstant_function_value( &::SireCAS::Conditional::isConstant );
Conditional_exposer.def(
"isConstant"
, isConstant_function_value
, "Return whether or not this is constant" );
}
{ //::SireCAS::Conditional::isFunction
typedef bool ( ::SireCAS::Conditional::*isFunction_function_type)( ::SireCAS::Symbol const & ) const;
isFunction_function_type isFunction_function_value( &::SireCAS::Conditional::isFunction );
Conditional_exposer.def(
"isFunction"
, isFunction_function_value
, ( bp::arg("arg0") )
, "Return whether or not this is a function of symbol" );
}
{ //::SireCAS::Conditional::isNull
typedef bool ( ::SireCAS::Conditional::*isNull_function_type)( ) const;
isNull_function_type isNull_function_value( &::SireCAS::Conditional::isNull );
Conditional_exposer.def(
"isNull"
, isNull_function_value
, "Return whether or not this is null" );
}
{ //::SireCAS::Conditional::operator=
typedef ::SireCAS::Conditional & ( ::SireCAS::Conditional::*assign_function_type)( ::SireCAS::Conditional const & ) ;
assign_function_type assign_function_value( &::SireCAS::Conditional::operator= );
Conditional_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
Conditional_exposer.def( bp::self == bp::self );
Conditional_exposer.def( bp::self == bp::other< SireCAS::ExBase >() );
{ //::SireCAS::Conditional::series
typedef ::SireCAS::Expression ( ::SireCAS::Conditional::*series_function_type)( ::SireCAS::Symbol const &,int ) const;
series_function_type series_function_value( &::SireCAS::Conditional::series );
Conditional_exposer.def(
"series"
, series_function_value
, ( bp::arg("symbol"), bp::arg("n") )
, "Return the series expansion of this product with respect to symbol, to order n" );
}
{ //::SireCAS::Conditional::simplify
typedef ::SireCAS::Expression ( ::SireCAS::Conditional::*simplify_function_type)( int ) const;
simplify_function_type simplify_function_value( &::SireCAS::Conditional::simplify );
Conditional_exposer.def(
"simplify"
, simplify_function_value
, ( bp::arg("options")=(int)(0) )
, "Try to simplify this condition" );
}
{ //::SireCAS::Conditional::substitute
typedef ::SireCAS::Expression ( ::SireCAS::Conditional::*substitute_function_type)( ::SireCAS::Identities const & ) const;
substitute_function_type substitute_function_value( &::SireCAS::Conditional::substitute );
Conditional_exposer.def(
"substitute"
, substitute_function_value
, ( bp::arg("identities") )
, "Substitute identities into this expression" );
}
{ //::SireCAS::Conditional::symbols
typedef ::SireCAS::Symbols ( ::SireCAS::Conditional::*symbols_function_type)( ) const;
symbols_function_type symbols_function_value( &::SireCAS::Conditional::symbols );
Conditional_exposer.def(
"symbols"
, symbols_function_value
, "Return the symbols used in this expression" );
}
{ //::SireCAS::Conditional::toString
typedef ::QString ( ::SireCAS::Conditional::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireCAS::Conditional::toString );
Conditional_exposer.def(
"toString"
, toString_function_value
, "Return a string representation of this conditional" );
}
{ //::SireCAS::Conditional::trueExpression
typedef ::SireCAS::Expression const & ( ::SireCAS::Conditional::*trueExpression_function_type)( ) const;
trueExpression_function_type trueExpression_function_value( &::SireCAS::Conditional::trueExpression );
Conditional_exposer.def(
"trueExpression"
, trueExpression_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the expression to be evaluated if the condition is true" );
}
{ //::SireCAS::Conditional::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireCAS::Conditional::typeName );
Conditional_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireCAS::Conditional::what
typedef char const * ( ::SireCAS::Conditional::*what_function_type)( ) const;
what_function_type what_function_value( &::SireCAS::Conditional::what );
Conditional_exposer.def(
"what"
, what_function_value
, "" );
}
Conditional_exposer.staticmethod( "typeName" );
Conditional_exposer.def( "__copy__", &__copy__);
Conditional_exposer.def( "__deepcopy__", &__copy__);
Conditional_exposer.def( "clone", &__copy__);
Conditional_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::Conditional >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Conditional_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::Conditional >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Conditional_exposer.def( "__str__", &__str__< ::SireCAS::Conditional > );
Conditional_exposer.def( "__repr__", &__str__< ::SireCAS::Conditional > );
Conditional_exposer.def( "__hash__", &::SireCAS::Conditional::hash );
}
}
void register_Condition_class(){
{ //::SireCAS::Condition
typedef bp::class_< SireCAS::Condition, bp::bases< SireCAS::ExBase >, boost::noncopyable > Condition_exposer_t;
Condition_exposer_t Condition_exposer = Condition_exposer_t( "Condition", bp::no_init );
bp::scope Condition_scope( Condition_exposer );
{ //::SireCAS::Condition::alwaysFalse
typedef bool ( ::SireCAS::Condition::*alwaysFalse_function_type )( ) const;
alwaysFalse_function_type alwaysFalse_function_value( &::SireCAS::Condition::alwaysFalse );
Condition_exposer.def(
"alwaysFalse"
, alwaysFalse_function_value );
}
{ //::SireCAS::Condition::alwaysTrue
typedef bool ( ::SireCAS::Condition::*alwaysTrue_function_type )( ) const;
alwaysTrue_function_type alwaysTrue_function_value( &::SireCAS::Condition::alwaysTrue );
Condition_exposer.def(
"alwaysTrue"
, alwaysTrue_function_value );
}
{ //::SireCAS::Condition::children
typedef ::SireCAS::Expressions ( ::SireCAS::Condition::*children_function_type )( ) const;
children_function_type children_function_value( &::SireCAS::Condition::children );
Condition_exposer.def(
"children"
, children_function_value );
}
{ //::SireCAS::Condition::conjugate
typedef ::SireCAS::Expression ( ::SireCAS::Condition::*conjugate_function_type )( ) const;
conjugate_function_type conjugate_function_value( &::SireCAS::Condition::conjugate );
Condition_exposer.def(
"conjugate"
, conjugate_function_value );
}
{ //::SireCAS::Condition::differentiate
typedef ::SireCAS::Expression ( ::SireCAS::Condition::*differentiate_function_type )( ::SireCAS::Symbol const & ) const;
differentiate_function_type differentiate_function_value( &::SireCAS::Condition::differentiate );
Condition_exposer.def(
"differentiate"
, differentiate_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireCAS::Condition::evaluate
typedef double ( ::SireCAS::Condition::*evaluate_function_type )( ::SireCAS::Values const & ) const;
evaluate_function_type evaluate_function_value( &::SireCAS::Condition::evaluate );
Condition_exposer.def(
"evaluate"
, evaluate_function_value
, ( bp::arg("values") ) );
}
{ //::SireCAS::Condition::evaluate
typedef ::SireMaths::Complex ( ::SireCAS::Condition::*evaluate_function_type )( ::SireCAS::ComplexValues const & ) const;
evaluate_function_type evaluate_function_value( &::SireCAS::Condition::evaluate );
Condition_exposer.def(
"evaluate"
, evaluate_function_value
, ( bp::arg("values") ) );
}
{ //::SireCAS::Condition::evaluateCondition
typedef bool ( ::SireCAS::Condition::*evaluateCondition_function_type )( ::SireCAS::Values const & ) const;
evaluateCondition_function_type evaluateCondition_function_value( &::SireCAS::Condition::evaluateCondition );
Condition_exposer.def(
"evaluateCondition"
, evaluateCondition_function_value
, ( bp::arg("values") ) );
}
{ //::SireCAS::Condition::evaluateCondition
typedef bool ( ::SireCAS::Condition::*evaluateCondition_function_type )( ::SireCAS::ComplexValues const & ) const;
evaluateCondition_function_type evaluateCondition_function_value( &::SireCAS::Condition::evaluateCondition );
Condition_exposer.def(
"evaluateCondition"
, evaluateCondition_function_value
, ( bp::arg("values") ) );
}
{ //::SireCAS::Condition::expand
typedef ::QList< SireCAS::Factor > ( ::SireCAS::Condition::*expand_function_type )( ::SireCAS::Symbol const & ) const;
expand_function_type expand_function_value( &::SireCAS::Condition::expand );
Condition_exposer.def(
"expand"
, expand_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireCAS::Condition::functions
typedef ::SireCAS::Functions ( ::SireCAS::Condition::*functions_function_type )( ) const;
functions_function_type functions_function_value( &::SireCAS::Condition::functions );
Condition_exposer.def(
"functions"
, functions_function_value );
}
{ //::SireCAS::Condition::hash
typedef ::uint ( ::SireCAS::Condition::*hash_function_type )( ) const;
hash_function_type hash_function_value( &::SireCAS::Condition::hash );
Condition_exposer.def(
"hash"
, hash_function_value );
}
{ //::SireCAS::Condition::integrate
typedef ::SireCAS::Expression ( ::SireCAS::Condition::*integrate_function_type )( ::SireCAS::Symbol const & ) const;
integrate_function_type integrate_function_value( &::SireCAS::Condition::integrate );
Condition_exposer.def(
"integrate"
, integrate_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireCAS::Condition::isComplex
typedef bool ( ::SireCAS::Condition::*isComplex_function_type )( ) const;
isComplex_function_type isComplex_function_value( &::SireCAS::Condition::isComplex );
Condition_exposer.def(
"isComplex"
, isComplex_function_value );
}
{ //::SireCAS::Condition::isCompound
typedef bool ( ::SireCAS::Condition::*isCompound_function_type )( ) const;
isCompound_function_type isCompound_function_value( &::SireCAS::Condition::isCompound );
Condition_exposer.def(
"isCompound"
, isCompound_function_value );
}
{ //::SireCAS::Condition::isConstant
typedef bool ( ::SireCAS::Condition::*isConstant_function_type )( ) const;
isConstant_function_type isConstant_function_value( &::SireCAS::Condition::isConstant );
Condition_exposer.def(
"isConstant"
, isConstant_function_value );
}
{ //::SireCAS::Condition::isFunction
typedef bool ( ::SireCAS::Condition::*isFunction_function_type )( ::SireCAS::Symbol const & ) const;
isFunction_function_type isFunction_function_value( &::SireCAS::Condition::isFunction );
Condition_exposer.def(
"isFunction"
, isFunction_function_value
, ( bp::arg("arg0") ) );
}
{ //::SireCAS::Condition::isNull
typedef bool ( ::SireCAS::Condition::*isNull_function_type )( ) const;
isNull_function_type isNull_function_value( &::SireCAS::Condition::isNull );
Condition_exposer.def(
"isNull"
, isNull_function_value );
}
{ //::SireCAS::Condition::leftHandSide
typedef ::SireCAS::Expression const & ( ::SireCAS::Condition::*leftHandSide_function_type )( ) const;
leftHandSide_function_type leftHandSide_function_value( &::SireCAS::Condition::leftHandSide );
Condition_exposer.def(
"leftHandSide"
, leftHandSide_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireCAS::Condition::rightHandSide
typedef ::SireCAS::Expression const & ( ::SireCAS::Condition::*rightHandSide_function_type )( ) const;
rightHandSide_function_type rightHandSide_function_value( &::SireCAS::Condition::rightHandSide );
Condition_exposer.def(
"rightHandSide"
, rightHandSide_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireCAS::Condition::simplify
typedef ::SireCAS::Expression ( ::SireCAS::Condition::*simplify_function_type )( int ) const;
simplify_function_type simplify_function_value( &::SireCAS::Condition::simplify );
Condition_exposer.def(
"simplify"
, simplify_function_value
, ( bp::arg("options")=(int)(0) ) );
}
{ //::SireCAS::Condition::substitute
typedef ::SireCAS::Expression ( ::SireCAS::Condition::*substitute_function_type )( ::SireCAS::Identities const & ) const;
substitute_function_type substitute_function_value( &::SireCAS::Condition::substitute );
Condition_exposer.def(
"substitute"
, substitute_function_value
, ( bp::arg("identities") ) );
}
{ //::SireCAS::Condition::symbols
typedef ::SireCAS::Symbols ( ::SireCAS::Condition::*symbols_function_type )( ) const;
symbols_function_type symbols_function_value( &::SireCAS::Condition::symbols );
Condition_exposer.def(
"symbols"
, symbols_function_value );
}
{ //::SireCAS::Condition::toString
typedef ::QString ( ::SireCAS::Condition::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireCAS::Condition::toString );
Condition_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireCAS::Condition::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireCAS::Condition::typeName );
Condition_exposer.def(
"typeName"
, typeName_function_value );
}
Condition_exposer.staticmethod( "typeName" );
Condition_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::Condition >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Condition_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::Condition >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Condition_exposer.def( "__str__", &__str__< ::SireCAS::Condition > );
Condition_exposer.def( "__repr__", &__str__< ::SireCAS::Condition > );
}
}
void register_Product_class(){
{ //::SireCAS::Product
typedef bp::class_< SireCAS::Product, bp::bases< SireCAS::ExBase > > Product_exposer_t;
Product_exposer_t Product_exposer = Product_exposer_t( "Product", bp::init< >() );
bp::scope Product_scope( Product_exposer );
Product_exposer.def( bp::init< SireCAS::Expression const &, SireCAS::Expression const & >(( bp::arg("ex0"), bp::arg("ex1") )) );
Product_exposer.def( bp::init< SireCAS::Expressions const & >(( bp::arg("expressions") )) );
Product_exposer.def( bp::init< SireCAS::Product const & >(( bp::arg("other") )) );
{ //::SireCAS::Product::children
typedef ::SireCAS::Expressions ( ::SireCAS::Product::*children_function_type )( ) const;
children_function_type children_function_value( &::SireCAS::Product::children );
Product_exposer.def(
"children"
, children_function_value );
}
{ //::SireCAS::Product::conjugate
typedef ::SireCAS::Expression ( ::SireCAS::Product::*conjugate_function_type )( ) const;
conjugate_function_type conjugate_function_value( &::SireCAS::Product::conjugate );
Product_exposer.def(
"conjugate"
, conjugate_function_value );
}
{ //::SireCAS::Product::denominator
typedef ::SireCAS::Product ( ::SireCAS::Product::*denominator_function_type )( ) const;
denominator_function_type denominator_function_value( &::SireCAS::Product::denominator );
Product_exposer.def(
"denominator"
, denominator_function_value );
}
{ //::SireCAS::Product::differentiate
typedef ::SireCAS::Expression ( ::SireCAS::Product::*differentiate_function_type )( ::SireCAS::Symbol const & ) const;
differentiate_function_type differentiate_function_value( &::SireCAS::Product::differentiate );
Product_exposer.def(
"differentiate"
, differentiate_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireCAS::Product::evaluate
typedef double ( ::SireCAS::Product::*evaluate_function_type )( ::SireCAS::Values const & ) const;
evaluate_function_type evaluate_function_value( &::SireCAS::Product::evaluate );
Product_exposer.def(
"evaluate"
, evaluate_function_value
, ( bp::arg("values") ) );
}
{ //::SireCAS::Product::evaluate
typedef ::SireMaths::Complex ( ::SireCAS::Product::*evaluate_function_type )( ::SireCAS::ComplexValues const & ) const;
evaluate_function_type evaluate_function_value( &::SireCAS::Product::evaluate );
Product_exposer.def(
"evaluate"
, evaluate_function_value
, ( bp::arg("values") ) );
}
{ //::SireCAS::Product::expand
typedef ::QList< SireCAS::Factor > ( ::SireCAS::Product::*expand_function_type )( ::SireCAS::Symbol const & ) const;
expand_function_type expand_function_value( &::SireCAS::Product::expand );
Product_exposer.def(
"expand"
, expand_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireCAS::Product::functions
typedef ::SireCAS::Functions ( ::SireCAS::Product::*functions_function_type )( ) const;
functions_function_type functions_function_value( &::SireCAS::Product::functions );
Product_exposer.def(
"functions"
, functions_function_value );
}
{ //::SireCAS::Product::hash
typedef ::uint ( ::SireCAS::Product::*hash_function_type )( ) const;
hash_function_type hash_function_value( &::SireCAS::Product::hash );
Product_exposer.def(
"hash"
, hash_function_value );
}
{ //::SireCAS::Product::integrate
typedef ::SireCAS::Expression ( ::SireCAS::Product::*integrate_function_type )( ::SireCAS::Symbol const & ) const;
integrate_function_type integrate_function_value( &::SireCAS::Product::integrate );
Product_exposer.def(
"integrate"
, integrate_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireCAS::Product::isComplex
typedef bool ( ::SireCAS::Product::*isComplex_function_type )( ) const;
isComplex_function_type isComplex_function_value( &::SireCAS::Product::isComplex );
Product_exposer.def(
"isComplex"
, isComplex_function_value );
}
{ //::SireCAS::Product::isCompound
typedef bool ( ::SireCAS::Product::*isCompound_function_type )( ) const;
isCompound_function_type isCompound_function_value( &::SireCAS::Product::isCompound );
Product_exposer.def(
"isCompound"
, isCompound_function_value );
}
{ //::SireCAS::Product::isConstant
typedef bool ( ::SireCAS::Product::*isConstant_function_type )( ) const;
isConstant_function_type isConstant_function_value( &::SireCAS::Product::isConstant );
Product_exposer.def(
"isConstant"
, isConstant_function_value );
}
{ //::SireCAS::Product::isFunction
typedef bool ( ::SireCAS::Product::*isFunction_function_type )( ::SireCAS::Symbol const & ) const;
isFunction_function_type isFunction_function_value( &::SireCAS::Product::isFunction );
Product_exposer.def(
"isFunction"
, isFunction_function_value
, ( bp::arg("arg0") ) );
}
{ //::SireCAS::Product::numerator
typedef ::SireCAS::Product ( ::SireCAS::Product::*numerator_function_type )( ) const;
numerator_function_type numerator_function_value( &::SireCAS::Product::numerator );
Product_exposer.def(
"numerator"
, numerator_function_value );
}
Product_exposer.def( bp::self == bp::other< SireCAS::ExBase >() );
{ //::SireCAS::Product::reduce
typedef ::SireCAS::Expression ( ::SireCAS::Product::*reduce_function_type )( ) const;
reduce_function_type reduce_function_value( &::SireCAS::Product::reduce );
Product_exposer.def(
"reduce"
, reduce_function_value );
}
{ //::SireCAS::Product::series
typedef ::SireCAS::Expression ( ::SireCAS::Product::*series_function_type )( ::SireCAS::Symbol const &,int ) const;
series_function_type series_function_value( &::SireCAS::Product::series );
Product_exposer.def(
"series"
, series_function_value
, ( bp::arg("symbol"), bp::arg("n") ) );
}
{ //::SireCAS::Product::simplify
typedef ::SireCAS::Expression ( ::SireCAS::Product::*simplify_function_type )( int ) const;
simplify_function_type simplify_function_value( &::SireCAS::Product::simplify );
Product_exposer.def(
"simplify"
, simplify_function_value
, ( bp::arg("options")=(int)(0) ) );
}
{ //::SireCAS::Product::substitute
typedef ::SireCAS::Expression ( ::SireCAS::Product::*substitute_function_type )( ::SireCAS::Identities const & ) const;
substitute_function_type substitute_function_value( &::SireCAS::Product::substitute );
Product_exposer.def(
"substitute"
, substitute_function_value
, ( bp::arg("identities") ) );
}
{ //::SireCAS::Product::symbols
typedef ::SireCAS::Symbols ( ::SireCAS::Product::*symbols_function_type )( ) const;
symbols_function_type symbols_function_value( &::SireCAS::Product::symbols );
Product_exposer.def(
"symbols"
, symbols_function_value );
}
{ //::SireCAS::Product::toString
typedef ::QString ( ::SireCAS::Product::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireCAS::Product::toString );
Product_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireCAS::Product::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireCAS::Product::typeName );
Product_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireCAS::Product::what
typedef char const * ( ::SireCAS::Product::*what_function_type )( ) const;
what_function_type what_function_value( &::SireCAS::Product::what );
Product_exposer.def(
"what"
, what_function_value );
}
Product_exposer.staticmethod( "typeName" );
Product_exposer.def( "__copy__", &__copy__);
Product_exposer.def( "__deepcopy__", &__copy__);
Product_exposer.def( "clone", &__copy__);
Product_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::Product >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Product_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::Product >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Product_exposer.def( "__str__", &__str__< ::SireCAS::Product > );
Product_exposer.def( "__repr__", &__str__< ::SireCAS::Product > );
}
}
void register_NullIntegrator_class(){
{ //::SireMove::NullIntegrator
typedef bp::class_< SireMove::NullIntegrator, bp::bases< SireMove::Integrator, SireBase::Property > > NullIntegrator_exposer_t;
NullIntegrator_exposer_t NullIntegrator_exposer = NullIntegrator_exposer_t( "NullIntegrator", bp::init< >() );
bp::scope NullIntegrator_scope( NullIntegrator_exposer );
NullIntegrator_exposer.def( bp::init< SireMove::NullIntegrator const & >(( bp::arg("other") )) );
{ //::SireMove::NullIntegrator::createWorkspace
typedef ::SireMove::IntegratorWorkspacePtr ( ::SireMove::NullIntegrator::*createWorkspace_function_type )( ::SireBase::PropertyMap const & ) const;
createWorkspace_function_type createWorkspace_function_value( &::SireMove::NullIntegrator::createWorkspace );
NullIntegrator_exposer.def(
"createWorkspace"
, createWorkspace_function_value
, ( bp::arg("map")=SireBase::PropertyMap() ) );
}
{ //::SireMove::NullIntegrator::createWorkspace
typedef ::SireMove::IntegratorWorkspacePtr ( ::SireMove::NullIntegrator::*createWorkspace_function_type )( ::SireMol::MoleculeGroup const &,::SireBase::PropertyMap const & ) const;
createWorkspace_function_type createWorkspace_function_value( &::SireMove::NullIntegrator::createWorkspace );
NullIntegrator_exposer.def(
"createWorkspace"
, createWorkspace_function_value
, ( bp::arg("molgroup"), bp::arg("map")=SireBase::PropertyMap() ) );
}
{ //::SireMove::NullIntegrator::ensemble
typedef ::SireMove::Ensemble ( ::SireMove::NullIntegrator::*ensemble_function_type )( ) const;
ensemble_function_type ensemble_function_value( &::SireMove::NullIntegrator::ensemble );
NullIntegrator_exposer.def(
"ensemble"
, ensemble_function_value );
}
{ //::SireMove::NullIntegrator::integrate
typedef void ( ::SireMove::NullIntegrator::*integrate_function_type )( ::SireMove::IntegratorWorkspace &,::SireCAS::Symbol const &,::SireUnits::Dimension::Time,int,bool ) const;
integrate_function_type integrate_function_value( &::SireMove::NullIntegrator::integrate );
NullIntegrator_exposer.def(
"integrate"
, integrate_function_value
, ( bp::arg("workspace"), bp::arg("nrg_component"), bp::arg("timestep"), bp::arg("nmoves"), bp::arg("record_stats") ) );
}
{ //::SireMove::NullIntegrator::isTimeReversible
typedef bool ( ::SireMove::NullIntegrator::*isTimeReversible_function_type )( ) const;
isTimeReversible_function_type isTimeReversible_function_value( &::SireMove::NullIntegrator::isTimeReversible );
NullIntegrator_exposer.def(
"isTimeReversible"
, isTimeReversible_function_value );
}
NullIntegrator_exposer.def( bp::self != bp::self );
{ //::SireMove::NullIntegrator::operator=
typedef ::SireMove::NullIntegrator & ( ::SireMove::NullIntegrator::*assign_function_type )( ::SireMove::NullIntegrator const & ) ;
assign_function_type assign_function_value( &::SireMove::NullIntegrator::operator= );
NullIntegrator_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
NullIntegrator_exposer.def( bp::self == bp::self );
{ //::SireMove::NullIntegrator::toString
typedef ::QString ( ::SireMove::NullIntegrator::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMove::NullIntegrator::toString );
NullIntegrator_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMove::NullIntegrator::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMove::NullIntegrator::typeName );
NullIntegrator_exposer.def(
"typeName"
, typeName_function_value );
}
NullIntegrator_exposer.staticmethod( "typeName" );
NullIntegrator_exposer.def( "__copy__", &__copy__);
NullIntegrator_exposer.def( "__deepcopy__", &__copy__);
NullIntegrator_exposer.def( "clone", &__copy__);
NullIntegrator_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMove::NullIntegrator >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
NullIntegrator_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMove::NullIntegrator >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
NullIntegrator_exposer.def( "__str__", &__str__< ::SireMove::NullIntegrator > );
NullIntegrator_exposer.def( "__repr__", &__str__< ::SireMove::NullIntegrator > );
}
}
void register_Symbol_class(){
{ //::SireCAS::Symbol
typedef bp::class_< SireCAS::Symbol, bp::bases< SireCAS::ExBase > > Symbol_exposer_t;
Symbol_exposer_t Symbol_exposer = Symbol_exposer_t( "Symbol", bp::init< >() );
bp::scope Symbol_scope( Symbol_exposer );
Symbol_exposer.def( bp::init< SireCAS::SymbolID >(( bp::arg("symid") )) );
Symbol_exposer.def( bp::init< QString const & >(( bp::arg("rep") )) );
Symbol_exposer.def( bp::init< SireCAS::Symbol const & >(( bp::arg("other") )) );
{ //::SireCAS::Symbol::ID
typedef ::SireCAS::SymbolID ( ::SireCAS::Symbol::*ID_function_type )( ) const;
ID_function_type ID_function_value( &::SireCAS::Symbol::ID );
Symbol_exposer.def(
"ID"
, ID_function_value );
}
{ //::SireCAS::Symbol::children
typedef ::SireCAS::Expressions ( ::SireCAS::Symbol::*children_function_type )( ) const;
children_function_type children_function_value( &::SireCAS::Symbol::children );
Symbol_exposer.def(
"children"
, children_function_value );
}
{ //::SireCAS::Symbol::differentiate
typedef ::SireCAS::Expression ( ::SireCAS::Symbol::*differentiate_function_type )( ::SireCAS::Symbol const & ) const;
differentiate_function_type differentiate_function_value( &::SireCAS::Symbol::differentiate );
Symbol_exposer.def(
"differentiate"
, differentiate_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireCAS::Symbol::evaluate
typedef double ( ::SireCAS::Symbol::*evaluate_function_type )( ::SireCAS::Values const & ) const;
evaluate_function_type evaluate_function_value( &::SireCAS::Symbol::evaluate );
Symbol_exposer.def(
"evaluate"
, evaluate_function_value
, ( bp::arg("values") ) );
}
{ //::SireCAS::Symbol::evaluate
typedef ::SireMaths::Complex ( ::SireCAS::Symbol::*evaluate_function_type )( ::SireCAS::ComplexValues const & ) const;
evaluate_function_type evaluate_function_value( &::SireCAS::Symbol::evaluate );
Symbol_exposer.def(
"evaluate"
, evaluate_function_value
, ( bp::arg("values") ) );
}
{ //::SireCAS::Symbol::expand
typedef ::QList< SireCAS::Factor > ( ::SireCAS::Symbol::*expand_function_type )( ::SireCAS::Symbol const & ) const;
expand_function_type expand_function_value( &::SireCAS::Symbol::expand );
Symbol_exposer.def(
"expand"
, expand_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireCAS::Symbol::functions
typedef ::SireCAS::Functions ( ::SireCAS::Symbol::*functions_function_type )( ) const;
functions_function_type functions_function_value( &::SireCAS::Symbol::functions );
Symbol_exposer.def(
"functions"
, functions_function_value );
}
{ //::SireCAS::Symbol::hash
typedef ::uint ( ::SireCAS::Symbol::*hash_function_type )( ) const;
hash_function_type hash_function_value( &::SireCAS::Symbol::hash );
Symbol_exposer.def(
"hash"
, hash_function_value );
}
{ //::SireCAS::Symbol::integrate
typedef ::SireCAS::Expression ( ::SireCAS::Symbol::*integrate_function_type )( ::SireCAS::Symbol const & ) const;
integrate_function_type integrate_function_value( &::SireCAS::Symbol::integrate );
Symbol_exposer.def(
"integrate"
, integrate_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireCAS::Symbol::isConstant
typedef bool ( ::SireCAS::Symbol::*isConstant_function_type )( ) const;
isConstant_function_type isConstant_function_value( &::SireCAS::Symbol::isConstant );
Symbol_exposer.def(
"isConstant"
, isConstant_function_value );
}
{ //::SireCAS::Symbol::isFunction
typedef bool ( ::SireCAS::Symbol::*isFunction_function_type )( ::SireCAS::Symbol const & ) const;
isFunction_function_type isFunction_function_value( &::SireCAS::Symbol::isFunction );
Symbol_exposer.def(
"isFunction"
, isFunction_function_value
, ( bp::arg("arg0") ) );
}
{ //::SireCAS::Symbol::isNull
typedef bool ( ::SireCAS::Symbol::*isNull_function_type )( ) const;
isNull_function_type isNull_function_value( &::SireCAS::Symbol::isNull );
Symbol_exposer.def(
"isNull"
, isNull_function_value );
}
Symbol_exposer.def( bp::self < bp::self );
Symbol_exposer.def( bp::self <= bp::self );
{ //::SireCAS::Symbol::operator=
typedef ::SireCAS::Symbol & ( ::SireCAS::Symbol::*assign_function_type )( ::SireCAS::Symbol const & ) ;
assign_function_type assign_function_value( &::SireCAS::Symbol::operator= );
Symbol_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
{ //::SireCAS::Symbol::operator=
typedef ::SireCAS::Symbol & ( ::SireCAS::Symbol::*assign_function_type )( ::SireCAS::SymbolID ) ;
assign_function_type assign_function_value( &::SireCAS::Symbol::operator= );
Symbol_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("symid") )
, bp::return_self< >() );
}
Symbol_exposer.def( bp::self == bp::other< double >() );
Symbol_exposer.def( bp::self == bp::other< int >() );
Symbol_exposer.def( bp::self == bp::other< SireMaths::Complex >() );
Symbol_exposer.def( bp::self == bp::other< SireCAS::Expression >() );
Symbol_exposer.def( bp::self == bp::other< SireCAS::ExBase >() );
Symbol_exposer.def( bp::self > bp::self );
Symbol_exposer.def( bp::self >= bp::self );
{ //::SireCAS::Symbol::substitute
typedef ::SireCAS::Expression ( ::SireCAS::Symbol::*substitute_function_type )( ::SireCAS::Identities const & ) const;
substitute_function_type substitute_function_value( &::SireCAS::Symbol::substitute );
Symbol_exposer.def(
"substitute"
, substitute_function_value
, ( bp::arg("identities") ) );
}
{ //::SireCAS::Symbol::symbols
typedef ::SireCAS::Symbols ( ::SireCAS::Symbol::*symbols_function_type )( ) const;
symbols_function_type symbols_function_value( &::SireCAS::Symbol::symbols );
Symbol_exposer.def(
"symbols"
, symbols_function_value );
}
{ //::SireCAS::Symbol::toString
typedef ::QString ( ::SireCAS::Symbol::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireCAS::Symbol::toString );
Symbol_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireCAS::Symbol::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireCAS::Symbol::typeName );
Symbol_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireCAS::Symbol::what
typedef char const * ( ::SireCAS::Symbol::*what_function_type )( ) const;
what_function_type what_function_value( &::SireCAS::Symbol::what );
Symbol_exposer.def(
"what"
, what_function_value );
}
Symbol_exposer.staticmethod( "typeName" );
Symbol_exposer.def( "__copy__", &__copy__);
Symbol_exposer.def( "__deepcopy__", &__copy__);
Symbol_exposer.def( "clone", &__copy__);
Symbol_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::Symbol >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Symbol_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::Symbol >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Symbol_exposer.def( "__str__", &__str__< ::SireCAS::Symbol > );
Symbol_exposer.def( "__repr__", &__str__< ::SireCAS::Symbol > );
}
}
