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_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::toOpenMMString typedef ::QString ( ::SireCAS::ExpressionBase::*toOpenMMString_function_type )( ) const; toOpenMMString_function_type toOpenMMString_function_value( &::SireCAS::ExpressionBase::toOpenMMString ); ExpressionBase_exposer.def( "toOpenMMString" , toOpenMMString_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 > ); } }